rcf-protocol 1.1.0

package/bin/rcf-cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/cli/index.js');

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const MarkerParser_1 = require("../core/MarkerParser");
+const ComplianceValidator_1 = require("../core/ComplianceValidator");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.resolve)(__dirname, '../../package.json'), 'utf-8'));
+const program = new commander_1.Command();
+program
+    .name('rcf-cli')
+    .description('RCF Protocol CLI')
+    .version(pkg.version);
+program
+    .command('scan [directory]')
+    .description('Scan directory for RCF markers')
+    .option('-f, --format <type>', 'output format', 'pretty')
+    .option('--summary', 'show summary only')
+    .action(async (directory = '.', options) => {
+    const parser = new MarkerParser_1.MarkerParser();
+    const results = await parser.scan(directory);
+    if (options.summary) {
+        printSummary(results);
+    }
+    else {
+        printResults(results, options.format);
+    }
+});
+program
+    .command('validate [directory]')
+    .description('Validate RCF compliance')
+    .option('--strict', 'strict mode')
+    .action(async (directory = '.', options) => {
+    const parser = new MarkerParser_1.MarkerParser();
+    const results = await parser.scan(directory);
+    const validator = new ComplianceValidator_1.ComplianceValidator({ strict: options.strict });
+    const status = await validator.validate(results);
+    if (status.valid) {
+        console.log(chalk_1.default.green('✅ RCF compliance validated'));
+    }
+    else {
+        console.log(chalk_1.default.red('❌ RCF compliance failed'));
+        status.errors.forEach(e => console.log(chalk_1.default.red(`  • ${e.file}:${e.line} - ${e.message}`)));
+        process.exit(1);
+    }
+});
+function printSummary(results) {
+    const stats = { PUBLIC: 0, PROTECTED: 0, RESTRICTED: 0, NOTICE: 0 };
+    results.forEach(r => r.markers.forEach((m) => stats[m.type]++));
+    console.log(chalk_1.default.bold('\n📊 RCF Markers Summary:'));
+    console.log(`  ${chalk_1.default.green('[RCF:PUBLIC]')}: ${stats.PUBLIC}`);
+    console.log(`  ${chalk_1.default.yellow('[RCF:PROTECTED]')}: ${stats.PROTECTED}`);
+    console.log(`  ${chalk_1.default.red('[RCF:RESTRICTED]')}: ${stats.RESTRICTED}`);
+    console.log(`  ${chalk_1.default.blue('[RCF:NOTICE]')}: ${stats.NOTICE}`);
+    console.log(`  Total files: ${results.length}\n`);
+}
+function printResults(results, format) {
+    if (format === 'json') {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    results.forEach(({ file, markers }) => {
+        console.log(chalk_1.default.bold(`\n📄 ${file}`));
+        markers.forEach((m) => {
+            const color = m.type === 'PUBLIC' ? 'green' :
+                m.type === 'PROTECTED' ? 'yellow' :
+                    m.type === 'RESTRICTED' ? 'red' : 'blue';
+            console.log(`  ${chalk_1.default[color](m.marker.name)} Line ${m.line}: ${m.context.substring(0, 50)}...`);
+        });
+    });
+}
+program.parse();

package/dist/core/ComplianceValidator.d.ts

@@ -0,0 +1,14 @@
+import { ParseResult, ValidationError } from './types';
+interface ValidatorOptions {
+    strict?: boolean;
+}
+export declare class ComplianceValidator {
+    private strict;
+    constructor(options?: ValidatorOptions);
+    validate(results: ParseResult[]): Promise<{
+        valid: boolean;
+        errors: ValidationError[];
+        warnings: ValidationError[];
+    }>;
+}
+export {};

package/dist/core/ComplianceValidator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplianceValidator = void 0;
+class ComplianceValidator {
+    constructor(options = {}) {
+        this.strict = options.strict || false;
+    }
+    async validate(results) {
+        const errors = [];
+        const warnings = [];
+        for (const result of results) {
+            const hasNotice = result.markers.some(m => m.type === 'NOTICE');
+            const hasProtected = result.markers.some(m => m.type === 'PROTECTED');
+            const hasRestricted = result.markers.some(m => m.type === 'RESTRICTED');
+            if ((hasProtected || hasRestricted) && !hasNotice) {
+                const msg = `File contains PROTECTED/RESTRICTED markers but no [RCF:NOTICE]`;
+                if (this.strict) {
+                    errors.push({ file: result.file, line: 1, message: msg, severity: 'error' });
+                }
+                else {
+                    warnings.push({ file: result.file, line: 1, message: msg, severity: 'warning' });
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+}
+exports.ComplianceValidator = ComplianceValidator;

package/dist/core/MarkerParser.d.ts

@@ -0,0 +1,13 @@
+import { ParseResult, ParsedMarker } from './types';
+interface ParserOptions {
+    extensions?: string[];
+    ignore?: string[];
+}
+export declare class MarkerParser {
+    private extensions;
+    private ignore;
+    constructor(options?: ParserOptions);
+    scan(directory: string): Promise<ParseResult[]>;
+    parseFile(filePath: string): Promise<ParsedMarker[]>;
+}
+export {};

package/dist/core/MarkerParser.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkerParser = void 0;
+const fs = __importStar(require("fs/promises"));
+const glob_1 = require("glob");
+const constants_1 = require("./constants");
+class MarkerParser {
+    constructor(options = {}) {
+        this.extensions = options.extensions || ['.ts', '.js', '.tsx', '.jsx', '.py'];
+        this.ignore = options.ignore || ['node_modules/**', 'dist/**', '.git/**'];
+    }
+    async scan(directory) {
+        const pattern = `**/*{${this.extensions.join(',')}}`;
+        const files = await (0, glob_1.glob)(pattern, {
+            cwd: directory,
+            ignore: this.ignore,
+            absolute: true
+        });
+        const results = [];
+        for (const file of files) {
+            const markers = await this.parseFile(file);
+            if (markers.length > 0) {
+                results.push({ file, markers });
+            }
+        }
+        return results;
+    }
+    async parseFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        const markers = [];
+        lines.forEach((line, index) => {
+            const matches = line.matchAll(constants_1.MARKER_REGEX);
+            for (const match of matches) {
+                const type = match[1];
+                markers.push({
+                    type,
+                    marker: constants_1.RCF_MARKERS[type],
+                    line: index + 1,
+                    column: match.index || 0,
+                    context: line.trim()
+                });
+            }
+        });
+        return markers;
+    }
+}
+exports.MarkerParser = MarkerParser;

package/dist/core/constants.d.ts

@@ -0,0 +1,3 @@
+import { RCFMarker, RCFMarkerType } from './types';
+export declare const RCF_MARKERS: Record<RCFMarkerType, RCFMarker>;
+export declare const MARKER_REGEX: RegExp;

package/dist/core/constants.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKER_REGEX = exports.RCF_MARKERS = void 0;
+exports.RCF_MARKERS = {
+    PUBLIC: {
+        name: '[RCF:PUBLIC]',
+        level: 0,
+        description: 'Architecture and public concepts. Safe to discuss.',
+        permissions: ['read', 'study', 'audit', 'discuss']
+    },
+    PROTECTED: {
+        name: '[RCF:PROTECTED]',
+        level: 1,
+        description: 'Core methodology. Visible but not replicable.',
+        permissions: ['read', 'study', 'audit'],
+        restrictions: ['no-replication', 'no-automation', 'no-ml-training']
+    },
+    RESTRICTED: {
+        name: '[RCF:RESTRICTED]',
+        level: 2,
+        description: 'Highly sensitive implementation. Minimal rights.',
+        permissions: ['read'],
+        restrictions: ['no-replication', 'no-automation', 'no-ml-training', 'no-modification']
+    },
+    NOTICE: {
+        name: '[RCF:NOTICE]',
+        level: 'meta',
+        description: 'Triggers requirement for adjacent legal notice.',
+        action: 'require-notice'
+    }
+};
+exports.MARKER_REGEX = /\[RCF:(PUBLIC|PROTECTED|RESTRICTED|NOTICE)\]/g;

package/dist/core/types.d.ts

@@ -0,0 +1,26 @@
+export type RCFMarkerType = 'PUBLIC' | 'PROTECTED' | 'RESTRICTED' | 'NOTICE';
+export interface RCFMarker {
+    name: string;
+    level: number | 'meta';
+    description: string;
+    permissions?: string[];
+    restrictions?: string[];
+    action?: string;
+}
+export interface ParsedMarker {
+    type: RCFMarkerType;
+    marker: RCFMarker;
+    line: number;
+    column: number;
+    context: string;
+}
+export interface ParseResult {
+    file: string;
+    markers: ParsedMarker[];
+}
+export interface ValidationError {
+    file: string;
+    line: number;
+    message: string;
+    severity: 'error' | 'warning';
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { MarkerParser } from './core/MarkerParser';
+export { ComplianceValidator } from './core/ComplianceValidator';
+export { RCF_MARKERS, MARKER_REGEX } from './core/constants';
+export { RCFMarker, RCFMarkerType, ParseResult } from './core/types';
+export declare const VERSION = "1.1.0";

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.MARKER_REGEX = exports.RCF_MARKERS = exports.ComplianceValidator = exports.MarkerParser = void 0;
+var MarkerParser_1 = require("./core/MarkerParser");
+Object.defineProperty(exports, "MarkerParser", { enumerable: true, get: function () { return MarkerParser_1.MarkerParser; } });
+var ComplianceValidator_1 = require("./core/ComplianceValidator");
+Object.defineProperty(exports, "ComplianceValidator", { enumerable: true, get: function () { return ComplianceValidator_1.ComplianceValidator; } });
+var constants_1 = require("./core/constants");
+Object.defineProperty(exports, "RCF_MARKERS", { enumerable: true, get: function () { return constants_1.RCF_MARKERS; } });
+Object.defineProperty(exports, "MARKER_REGEX", { enumerable: true, get: function () { return constants_1.MARKER_REGEX; } });
+exports.VERSION = '1.1.0';

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "rcf-protocol",
+  "version": "1.1.0",
+  "description": "RCF Protocol SDK for TypeScript/JavaScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "rcf-cli": "bin/rcf-cli.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aliyevaladddin/rcf-protocol.git"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/cli/index.ts",
+    "clean": "rm -rf dist",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "glob": "^10.3.10"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/node": "^20.10.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.3.0"
+  }
+}