@rigour-labs/core 1.5.1 → 1.6.0

package/dist/services/state-service.d.ts

@@ -0,0 +1,26 @@
+export declare class StateService {
+    private statePath;
+    private state;
+    constructor(cwd: string);
+    private load;
+    private createEmpty;
+    /**
+     * Record violation occurrences for prioritization.
+     * PRIVACY: Only stores rule IDs and counts, never file contents or paths.
+     */
+    recordViolations(ruleIds: string[]): void;
+    /**
+     * Prioritize violations for Fix Packet ordering.
+     * Most frequent + recent violations appear first.
+     */
+    prioritize(ruleIds: string[]): string[];
+    /**
+     * Get repeat violation hints for agent feedback.
+     */
+    getRepeatHints(ruleIds: string[]): Record<string, string>;
+    save(): void;
+    /**
+     * Clear all state (user privacy action).
+     */
+    clear(): void;
+}

package/dist/services/state-service.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateService = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const STATE_DIR = '.rigour';
+const STATE_FILE = 'state.json';
+const CURRENT_VERSION = 1;
+class StateService {
+    statePath;
+    state;
+    constructor(cwd) {
+        this.statePath = path_1.default.join(cwd, STATE_DIR, STATE_FILE);
+        this.state = this.load();
+    }
+    load() {
+        try {
+            if (fs_extra_1.default.existsSync(this.statePath)) {
+                const content = fs_extra_1.default.readFileSync(this.statePath, 'utf-8');
+                return JSON.parse(content);
+            }
+        }
+        catch {
+            // Corrupted or missing state - reset
+        }
+        return this.createEmpty();
+    }
+    createEmpty() {
+        return {
+            version: CURRENT_VERSION,
+            createdAt: new Date().toISOString(),
+            violations: {},
+        };
+    }
+    /**
+     * Record violation occurrences for prioritization.
+     * PRIVACY: Only stores rule IDs and counts, never file contents or paths.
+     */
+    recordViolations(ruleIds) {
+        const now = new Date().toISOString();
+        for (const ruleId of ruleIds) {
+            if (!this.state.violations[ruleId]) {
+                this.state.violations[ruleId] = { count: 0, lastSeen: now, coOccurs: {} };
+            }
+            this.state.violations[ruleId].count++;
+            this.state.violations[ruleId].lastSeen = now;
+            // Track co-occurrences for pattern detection
+            for (const otherId of ruleIds) {
+                if (otherId !== ruleId) {
+                    this.state.violations[ruleId].coOccurs[otherId] =
+                        (this.state.violations[ruleId].coOccurs[otherId] || 0) + 1;
+                }
+            }
+        }
+    }
+    /**
+     * Prioritize violations for Fix Packet ordering.
+     * Most frequent + recent violations appear first.
+     */
+    prioritize(ruleIds) {
+        return [...ruleIds].sort((a, b) => {
+            const statsA = this.state.violations[a];
+            const statsB = this.state.violations[b];
+            if (!statsA && !statsB)
+                return 0;
+            if (!statsA)
+                return 1;
+            if (!statsB)
+                return -1;
+            // Higher count = higher priority
+            return statsB.count - statsA.count;
+        });
+    }
+    /**
+     * Get repeat violation hints for agent feedback.
+     */
+    getRepeatHints(ruleIds) {
+        const hints = {};
+        for (const ruleId of ruleIds) {
+            const stats = this.state.violations[ruleId];
+            if (stats && stats.count > 2) {
+                hints[ruleId] = `This violation has occurred ${stats.count} times. Consider root-cause analysis.`;
+            }
+        }
+        return hints;
+    }
+    save() {
+        try {
+            fs_extra_1.default.ensureDirSync(path_1.default.dirname(this.statePath));
+            fs_extra_1.default.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+        }
+        catch {
+            // Silent fail - state is optional
+        }
+    }
+    /**
+     * Clear all state (user privacy action).
+     */
+    clear() {
+        this.state = this.createEmpty();
+        try {
+            fs_extra_1.default.removeSync(this.statePath);
+        }
+        catch {
+            // Silent fail
+        }
+    }
+}
+exports.StateService = StateService;

package/dist/templates/index.js

@@ -100,26 +100,51 @@ exports.PARADIGM_TEMPLATES = [
             'interface ',
             'implements ',
             'extends ',
+            'constructor(',
+            'private ',
+            'public ',
+            'protected ',
         ],
         config: {
             paradigm: 'oop',
             gates: {
-            // Future: class-specific gates
+                max_file_lines: 400,
+                ast: {
+                    complexity: 10,
+                    max_methods: 10,
+                    max_params: 5,
+                    max_nesting: 4,
+                    max_inheritance_depth: 3,
+                    max_class_dependencies: 5,
+                    max_function_lines: 60,
+                },
             },
         },
     },
     {
         name: 'functional',
+        // Removed '=>' as primary marker - too broad (appears in OOP callbacks)
         markers: [
-            '=>',
             'export const',
-            'map(',
-            'filter(',
+            'reduce(',
+            '.pipe(',
+            'compose(',
+            'curry(',
+            'readonly ',
         ],
         config: {
             paradigm: 'functional',
             gates: {
-            // Future: function-specific gates
+                max_file_lines: 350,
+                ast: {
+                    complexity: 8,
+                    max_methods: 15, // Functions, not classes
+                    max_params: 4,
+                    max_nesting: 3,
+                    max_inheritance_depth: 3,
+                    max_class_dependencies: 5,
+                    max_function_lines: 40,
+                },
             },
         },
     },
@@ -137,6 +162,10 @@ exports.UNIVERSAL_CONFIG = {
             complexity: 10,
             max_methods: 10,
             max_params: 5,
+            max_nesting: 4,
+            max_inheritance_depth: 3,
+            max_class_dependencies: 5,
+            max_function_lines: 50,
         },
         dependencies: {
             forbid: [],

package/dist/types/index.d.ts

@@ -9,14 +9,26 @@ export declare const GatesSchema: z.ZodObject<{
         complexity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         max_methods: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         max_params: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_nesting: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_inheritance_depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_class_dependencies: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        max_function_lines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     }, "strip", z.ZodTypeAny, {
         complexity: number;
         max_methods: number;
         max_params: number;
+        max_nesting: number;
+        max_inheritance_depth: number;
+        max_class_dependencies: number;
+        max_function_lines: number;
     }, {
         complexity?: number | undefined;
         max_methods?: number | undefined;
         max_params?: number | undefined;
+        max_nesting?: number | undefined;
+        max_inheritance_depth?: number | undefined;
+        max_class_dependencies?: number | undefined;
+        max_function_lines?: number | undefined;
     }>>>;
     dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         forbid: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
@@ -75,6 +87,10 @@ export declare const GatesSchema: z.ZodObject<{
         complexity: number;
         max_methods: number;
         max_params: number;
+        max_nesting: number;
+        max_inheritance_depth: number;
+        max_class_dependencies: number;
+        max_function_lines: number;
     };
     dependencies: {
         forbid: string[];
@@ -101,6 +117,10 @@ export declare const GatesSchema: z.ZodObject<{
         complexity?: number | undefined;
         max_methods?: number | undefined;
         max_params?: number | undefined;
+        max_nesting?: number | undefined;
+        max_inheritance_depth?: number | undefined;
+        max_class_dependencies?: number | undefined;
+        max_function_lines?: number | undefined;
     } | undefined;
     dependencies?: {
         forbid?: string[] | undefined;
@@ -164,14 +184,26 @@ export declare const ConfigSchema: z.ZodObject<{
             complexity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
             max_methods: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
             max_params: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_nesting: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_inheritance_depth: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_class_dependencies: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            max_function_lines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         }, "strip", z.ZodTypeAny, {
             complexity: number;
             max_methods: number;
             max_params: number;
+            max_nesting: number;
+            max_inheritance_depth: number;
+            max_class_dependencies: number;
+            max_function_lines: number;
         }, {
             complexity?: number | undefined;
             max_methods?: number | undefined;
             max_params?: number | undefined;
+            max_nesting?: number | undefined;
+            max_inheritance_depth?: number | undefined;
+            max_class_dependencies?: number | undefined;
+            max_function_lines?: number | undefined;
         }>>>;
         dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             forbid: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
@@ -230,6 +262,10 @@ export declare const ConfigSchema: z.ZodObject<{
             complexity: number;
             max_methods: number;
             max_params: number;
+            max_nesting: number;
+            max_inheritance_depth: number;
+            max_class_dependencies: number;
+            max_function_lines: number;
         };
         dependencies: {
             forbid: string[];
@@ -256,6 +292,10 @@ export declare const ConfigSchema: z.ZodObject<{
             complexity?: number | undefined;
             max_methods?: number | undefined;
             max_params?: number | undefined;
+            max_nesting?: number | undefined;
+            max_inheritance_depth?: number | undefined;
+            max_class_dependencies?: number | undefined;
+            max_function_lines?: number | undefined;
         } | undefined;
         dependencies?: {
             forbid?: string[] | undefined;
@@ -299,6 +339,10 @@ export declare const ConfigSchema: z.ZodObject<{
             complexity: number;
             max_methods: number;
             max_params: number;
+            max_nesting: number;
+            max_inheritance_depth: number;
+            max_class_dependencies: number;
+            max_function_lines: number;
         };
         dependencies: {
             forbid: string[];
@@ -342,6 +386,10 @@ export declare const ConfigSchema: z.ZodObject<{
             complexity?: number | undefined;
             max_methods?: number | undefined;
             max_params?: number | undefined;
+            max_nesting?: number | undefined;
+            max_inheritance_depth?: number | undefined;
+            max_class_dependencies?: number | undefined;
+            max_function_lines?: number | undefined;
         } | undefined;
         dependencies?: {
             forbid?: string[] | undefined;

package/dist/types/index.js

@@ -17,6 +17,10 @@ exports.GatesSchema = zod_1.z.object({
         complexity: zod_1.z.number().optional().default(10),
         max_methods: zod_1.z.number().optional().default(10),
         max_params: zod_1.z.number().optional().default(5),
+        max_nesting: zod_1.z.number().optional().default(4),
+        max_inheritance_depth: zod_1.z.number().optional().default(3),
+        max_class_dependencies: zod_1.z.number().optional().default(5),
+        max_function_lines: zod_1.z.number().optional().default(50),
     }).optional().default({}),
     dependencies: zod_1.z.object({
         forbid: zod_1.z.array(zod_1.z.string()).optional().default([]),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {

package/src/services/state-service.ts

@@ -0,0 +1,138 @@
+import fs from 'fs-extra';
+import path from 'path';
+import crypto from 'crypto';
+
+/**
+ * Local Calibration State Service
+ * 
+ * DOCTRINE COMPLIANCE (§6):
+ * - Local-only, deletable, optional
+ * - Used ONLY for prioritization, ordering, early warnings
+ * - NEVER stores: source code, file contents, raw paths, prompts, user identifiers
+ * - State NEVER changes PASS/FAIL results (only ordering/messaging)
+ */
+
+interface ViolationStats {
+    count: number;
+    lastSeen: string; // ISO timestamp
+    coOccurs: Record<string, number>; // Rule ID -> co-occurrence count
+}
+
+interface LocalState {
+    version: number;
+    createdAt: string;
+    violations: Record<string, ViolationStats>; // Rule ID -> stats
+}
+
+const STATE_DIR = '.rigour';
+const STATE_FILE = 'state.json';
+const CURRENT_VERSION = 1;
+
+export class StateService {
+    private statePath: string;
+    private state: LocalState;
+
+    constructor(cwd: string) {
+        this.statePath = path.join(cwd, STATE_DIR, STATE_FILE);
+        this.state = this.load();
+    }
+
+    private load(): LocalState {
+        try {
+            if (fs.existsSync(this.statePath)) {
+                const content = fs.readFileSync(this.statePath, 'utf-8');
+                return JSON.parse(content);
+            }
+        } catch {
+            // Corrupted or missing state - reset
+        }
+        return this.createEmpty();
+    }
+
+    private createEmpty(): LocalState {
+        return {
+            version: CURRENT_VERSION,
+            createdAt: new Date().toISOString(),
+            violations: {},
+        };
+    }
+
+    /**
+     * Record violation occurrences for prioritization.
+     * PRIVACY: Only stores rule IDs and counts, never file contents or paths.
+     */
+    recordViolations(ruleIds: string[]): void {
+        const now = new Date().toISOString();
+
+        for (const ruleId of ruleIds) {
+            if (!this.state.violations[ruleId]) {
+                this.state.violations[ruleId] = { count: 0, lastSeen: now, coOccurs: {} };
+            }
+            this.state.violations[ruleId].count++;
+            this.state.violations[ruleId].lastSeen = now;
+
+            // Track co-occurrences for pattern detection
+            for (const otherId of ruleIds) {
+                if (otherId !== ruleId) {
+                    this.state.violations[ruleId].coOccurs[otherId] =
+                        (this.state.violations[ruleId].coOccurs[otherId] || 0) + 1;
+                }
+            }
+        }
+    }
+
+    /**
+     * Prioritize violations for Fix Packet ordering.
+     * Most frequent + recent violations appear first.
+     */
+    prioritize(ruleIds: string[]): string[] {
+        return [...ruleIds].sort((a, b) => {
+            const statsA = this.state.violations[a];
+            const statsB = this.state.violations[b];
+
+            if (!statsA && !statsB) return 0;
+            if (!statsA) return 1;
+            if (!statsB) return -1;
+
+            // Higher count = higher priority
+            return statsB.count - statsA.count;
+        });
+    }
+
+    /**
+     * Get repeat violation hints for agent feedback.
+     */
+    getRepeatHints(ruleIds: string[]): Record<string, string> {
+        const hints: Record<string, string> = {};
+
+        for (const ruleId of ruleIds) {
+            const stats = this.state.violations[ruleId];
+            if (stats && stats.count > 2) {
+                hints[ruleId] = `This violation has occurred ${stats.count} times. Consider root-cause analysis.`;
+            }
+        }
+
+        return hints;
+    }
+
+    save(): void {
+        try {
+            fs.ensureDirSync(path.dirname(this.statePath));
+            fs.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+        } catch {
+            // Silent fail - state is optional
+        }
+    }
+
+    /**
+     * Clear all state (user privacy action).
+     */
+    clear(): void {
+        this.state = this.createEmpty();
+        try {
+            fs.removeSync(this.statePath);
+        } catch {
+            // Silent fail
+        }
+    }
+}

package/src/templates/index.ts

@@ -112,26 +112,51 @@ export const PARADIGM_TEMPLATES: Template[] = [
             'interface ',
             'implements ',
             'extends ',
+            'constructor(',
+            'private ',
+            'public ',
+            'protected ',
         ],
         config: {
             paradigm: 'oop',
             gates: {
-                // Future: class-specific gates
+                max_file_lines: 400,
+                ast: {
+                    complexity: 10,
+                    max_methods: 10,
+                    max_params: 5,
+                    max_nesting: 4,
+                    max_inheritance_depth: 3,
+                    max_class_dependencies: 5,
+                    max_function_lines: 60,
+                },
             },
         },
     },
     {
         name: 'functional',
+        // Removed '=>' as primary marker - too broad (appears in OOP callbacks)
         markers: [
-            '=>',
             'export const',
-            'map(',
-            'filter(',
+            'reduce(',
+            '.pipe(',
+            'compose(',
+            'curry(',
+            'readonly ',
         ],
         config: {
             paradigm: 'functional',
             gates: {
-                // Future: function-specific gates
+                max_file_lines: 350,
+                ast: {
+                    complexity: 8,
+                    max_methods: 15, // Functions, not classes
+                    max_params: 4,
+                    max_nesting: 3,
+                    max_inheritance_depth: 3,
+                    max_class_dependencies: 5,
+                    max_function_lines: 40,
+                },
             },
         },
     },
@@ -150,6 +175,10 @@ export const UNIVERSAL_CONFIG: Config = {
             complexity: 10,
             max_methods: 10,
             max_params: 5,
+            max_nesting: 4,
+            max_inheritance_depth: 3,
+            max_class_dependencies: 5,
+            max_function_lines: 50,
         },
         dependencies: {
             forbid: [],

package/src/types/index.ts

@@ -15,6 +15,10 @@ export const GatesSchema = z.object({
         complexity: z.number().optional().default(10),
         max_methods: z.number().optional().default(10),
         max_params: z.number().optional().default(5),
+        max_nesting: z.number().optional().default(4),
+        max_inheritance_depth: z.number().optional().default(3),
+        max_class_dependencies: z.number().optional().default(5),
+        max_function_lines: z.number().optional().default(50),
     }).optional().default({}),
     dependencies: z.object({
         forbid: z.array(z.string()).optional().default([]),