@rigour-labs/core 6.2.4 → 6.3.0

package/dist/utils/scope.js

@@ -0,0 +1,51 @@
+/**
+ * File scope for `rigour check <paths...>` and `rigour review`.
+ *
+ * CLI inputs may be absolute, relative or directories. Gates glob with
+ * globby, so each input becomes a cwd-relative glob with glob-special
+ * characters escaped (Next.js routes such as `app/[key]/route.ts` would
+ * otherwise be read as a character class).
+ */
+import path from 'path';
+import fs from 'fs-extra';
+import { convertPathToPattern } from 'globby';
+import { FileScanner } from './scanner.js';
+/** Convert CLI path arguments into cwd-relative, escaped glob patterns. */
+export async function normalizeScopePatterns(cwd, inputs) {
+    const patterns = [];
+    for (const input of inputs) {
+        const absolute = path.resolve(cwd, input);
+        const relative = toPosix(path.relative(cwd, absolute)) || '.';
+        const isDirectory = await fs.stat(absolute).then(s => s.isDirectory()).catch(() => false);
+        if (!isDirectory && !(await fs.pathExists(absolute))) {
+            // Not a path on disk: keep it as the glob the user wrote.
+            patterns.push(toPosix(input));
+            continue;
+        }
+        const escaped = relative === '.' ? '' : convertPathToPattern(relative);
+        patterns.push(isDirectory ? (escaped ? `${escaped}/**/*` : '**/*') : escaped);
+    }
+    return patterns;
+}
+/** True when a gate context carries an explicit file scope. */
+export function isScoped(patterns) {
+    return Array.isArray(patterns) && patterns.length > 0;
+}
+/** True when any of `files` is in the scoped file set (paths compared cwd-relative). */
+export function touchesScope(files, scopedFiles) {
+    return (files ?? []).some(f => scopedFiles.has(toPosix(f).replace(/^\.\//, '')));
+}
+/** The concrete cwd-relative files matched by a scoped run's patterns. */
+export async function resolveScopedFiles(cwd, patterns, ignore) {
+    const files = await FileScanner.findFiles({ cwd, patterns, ignore });
+    return new Set(files.map(toPosix));
+}
+/** True when a scoped run does not include `file` (a manifest such as package.json). */
+export async function scopeExcludes(context, file) {
+    if (!isScoped(context.patterns))
+        return false;
+    return !(await resolveScopedFiles(context.cwd, context.patterns, context.ignore)).has(file);
+}
+export function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}

package/dist/utils/scope.test.d.ts

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

package/dist/utils/scope.test.js

@@ -0,0 +1,38 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { isScoped, normalizeScopePatterns, resolveScopedFiles, touchesScope } from './scope.js';
+describe('scope', () => {
+    let cwd;
+    beforeEach(async () => {
+        cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-scope-'));
+        await fs.outputFile(path.join(cwd, 'src/app/[key]/route.ts'), 'export {}');
+        await fs.outputFile(path.join(cwd, 'src/app/k/route.ts'), 'export {}');
+        await fs.outputFile(path.join(cwd, 'src/lib/a.ts'), 'export {}');
+    });
+    afterEach(async () => { await fs.remove(cwd); });
+    it('turns absolute, relative and directory inputs into cwd-relative patterns', async () => {
+        const patterns = await normalizeScopePatterns(cwd, [path.join(cwd, 'src/lib/a.ts'), './src/lib', 'src/lib/a.ts']);
+        expect(patterns).toEqual(['src/lib/a.ts', 'src/lib/**/*', 'src/lib/a.ts']);
+    });
+    it('escapes glob characters so a Next.js [key] route matches only itself', async () => {
+        const patterns = await normalizeScopePatterns(cwd, ['src/app/[key]/route.ts']);
+        expect([...await resolveScopedFiles(cwd, patterns)]).toEqual(['src/app/[key]/route.ts']);
+    });
+    it('keeps a non-existent input as the glob the user wrote', async () => {
+        expect(await normalizeScopePatterns(cwd, ['src/**/*.ts'])).toEqual(['src/**/*.ts']);
+    });
+    it('treats the repo root as everything', async () => {
+        expect(await normalizeScopePatterns(cwd, ['.'])).toEqual(['**/*']);
+    });
+    it('detects scoped runs and scope membership', () => {
+        expect(isScoped(undefined)).toBe(false);
+        expect(isScoped([])).toBe(false);
+        expect(isScoped(['a.ts'])).toBe(true);
+        const scoped = new Set(['src/lib/a.ts']);
+        expect(touchesScope(['./src/lib/a.ts', 'b.ts'], scoped)).toBe(true);
+        expect(touchesScope(['b.ts'], scoped)).toBe(false);
+        expect(touchesScope(undefined, scoped)).toBe(false);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.2.4",
+  "version": "6.3.0",
   "description": "AI-native quality gate engine with local Bayesian learning. AST analysis, drift detection, Fix Packet generation, and agent self-healing across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -67,11 +67,11 @@
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "6.2.4",
-    "@rigour-labs/brain-darwin-x64": "6.2.4",
-    "@rigour-labs/brain-linux-x64": "6.2.4",
-    "@rigour-labs/brain-win-x64": "6.2.4",
-    "@rigour-labs/brain-linux-arm64": "6.2.4"
+    "@rigour-labs/brain-darwin-arm64": "6.3.0",
+    "@rigour-labs/brain-darwin-x64": "6.3.0",
+    "@rigour-labs/brain-linux-arm64": "6.3.0",
+    "@rigour-labs/brain-win-x64": "6.3.0",
+    "@rigour-labs/brain-linux-x64": "6.3.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",