@cmpsbl/runtime 1.0.0

package/README.md

@@ -0,0 +1,43 @@
+# @cmpsbl/runtime
+
+CMPSBL® Mini-Runtime™ Engine — the canonical execution runtime for the CMPSBL substrate.
+
+## Install
+
+```bash
+npm install @cmpsbl/runtime
+```
+
+## Quick Start
+
+```typescript
+import { createRuntime } from '@cmpsbl/runtime';
+
+const runtime = createRuntime();
+
+// Score a discovery
+const score = runtime.computeCJPI({ novelty: 80, utility: 90, complexity: 70, composability: 85 });
+console.log(score.total, score.tier); // 83 'Mythic'
+
+// Generate a manifest
+const manifest = runtime.generateManifest({ name: 'my-pipeline', cjpi: 83, modules: ['BRAIN', 'CORTEX'] });
+
+// Register custom primitives and execute chains
+runtime.registerPrimitive('BRAIN', (data) => ({
+  success: true, output: { analyzed: true, ...data }, confidence: 0.9, durationMs: 12, handler: 'brain-local'
+}));
+```
+
+## Features
+
+- **CJPI Scoring** — Crown Jewel Performance Index computation with weighted dimensions
+- **Auto-Tiering** — Automatic tier assignment (Mint → Apex)
+- **Manifest Parsing** — Parse and generate CMPSBL export manifests
+- **Pipeline Execution** — Chain execution with fallback handling
+- **State Machine** — Generic finite state machine
+- **Dependency Graph** — Topological sort for module ordering
+- **Zero Dependencies** — Pure TypeScript, runs anywhere
+
+## License
+
+Apache-2.0 © Kenneth E Sweet Jr

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @cmpsbl/runtime — Mini-Runtime™ Engine
+ * CMPSBL® Core Execution Runtime
+ *
+ * Zero-dependency CJPI scoring, auto-tiering, manifest parsing,
+ * state machine, saga orchestration, and pipeline execution.
+ *
+ * © CMPSBL® — All rights reserved.
+ */
+import type { CJPIInput, CJPIScoreBreakdown, CrystallizedTier, ProductTier, CmpsblManifest, ChainManifest, ChainResult, ExecutionOptions, PrimitiveResult } from '@cmpsbl/types';
+export type { CJPIInput, CJPIScoreBreakdown, CrystallizedTier, ProductTier, CmpsblManifest };
+export declare function computeCJPI(input: CJPIInput): CJPIScoreBreakdown;
+export declare function tierFromCJPI(score: number): CrystallizedTier;
+export declare function productTierFromScore(score: number): ProductTier;
+export declare function parseManifest(json: string): CmpsblManifest;
+export declare function generateManifest(input: {
+    name: string;
+    cjpi?: number;
+    modules?: string[];
+    targets?: string[];
+    version?: string;
+    category?: string;
+    fingerprint?: string;
+    source?: string;
+}): CmpsblManifest;
+export interface DependencyNode {
+    id: string;
+    dependencies: string[];
+}
+export declare function buildDependencyGraph(nodes: DependencyNode[]): Map<string, string[]>;
+export declare function topologicalSort(nodes: DependencyNode[]): string[];
+export interface StateMachineConfig<S extends string, E extends string> {
+    initial: S;
+    transitions: Record<S, Partial<Record<E, S>>>;
+}
+export declare class StateMachine<S extends string, E extends string> {
+    private current;
+    private readonly transitions;
+    constructor(config: StateMachineConfig<S, E>);
+    get state(): S;
+    send(event: E): S;
+    canSend(event: E): boolean;
+}
+export type PrimitiveHandler = (data: Record<string, unknown>, confidence: number) => PrimitiveResult | Promise<PrimitiveResult>;
+export declare function registerPrimitive(name: string, handler: PrimitiveHandler): void;
+export declare function executePrimitive(name: string, data: Record<string, unknown>, confidence: number): Promise<PrimitiveResult>;
+export declare function executeChain(manifest: ChainManifest, input: Record<string, unknown>, options?: ExecutionOptions): Promise<ChainResult>;
+export interface MiniRuntime {
+    computeCJPI: typeof computeCJPI;
+    tierFromCJPI: typeof tierFromCJPI;
+    productTierFromScore: typeof productTierFromScore;
+    parseManifest: typeof parseManifest;
+    generateManifest: typeof generateManifest;
+    topologicalSort: typeof topologicalSort;
+    registerPrimitive: typeof registerPrimitive;
+    executePrimitive: typeof executePrimitive;
+    executeChain: typeof executeChain;
+    createStateMachine: <S extends string, E extends string>(config: StateMachineConfig<S, E>) => StateMachine<S, E>;
+    version: string;
+}
+export declare function createRuntime(): MiniRuntime;

package/dist/index.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * @cmpsbl/runtime — Mini-Runtime™ Engine
+ * CMPSBL® Core Execution Runtime
+ *
+ * Zero-dependency CJPI scoring, auto-tiering, manifest parsing,
+ * state machine, saga orchestration, and pipeline execution.
+ *
+ * © CMPSBL® — All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachine = void 0;
+exports.computeCJPI = computeCJPI;
+exports.tierFromCJPI = tierFromCJPI;
+exports.productTierFromScore = productTierFromScore;
+exports.parseManifest = parseManifest;
+exports.generateManifest = generateManifest;
+exports.buildDependencyGraph = buildDependencyGraph;
+exports.topologicalSort = topologicalSort;
+exports.registerPrimitive = registerPrimitive;
+exports.executePrimitive = executePrimitive;
+exports.executeChain = executeChain;
+exports.createRuntime = createRuntime;
+// ═══════════════════════════════════════════════════════════════
+// §1 — CJPI Scoring Engine
+// ═══════════════════════════════════════════════════════════════
+const CJPI_WEIGHTS = {
+    novelty: 0.25,
+    utility: 0.35,
+    complexity: 0.20,
+    composability: 0.20,
+};
+function computeCJPI(input) {
+    const total = Math.round(input.novelty * CJPI_WEIGHTS.novelty +
+        input.utility * CJPI_WEIGHTS.utility +
+        input.complexity * CJPI_WEIGHTS.complexity +
+        input.composability * CJPI_WEIGHTS.composability);
+    return {
+        novelty: input.novelty,
+        utility: input.utility,
+        complexity: input.complexity,
+        composability: input.composability,
+        total: Math.max(0, Math.min(100, total)),
+        tier: tierFromCJPI(total),
+    };
+}
+function tierFromCJPI(score) {
+    if (score >= 90)
+        return 'Apex';
+    if (score >= 75)
+        return 'Mythic';
+    if (score >= 55)
+        return 'Relic';
+    if (score >= 35)
+        return 'Prime';
+    return 'Mint';
+}
+function productTierFromScore(score) {
+    if (score >= 90)
+        return 'Apex';
+    if (score >= 75)
+        return 'Enterprise';
+    if (score >= 55)
+        return 'Architect';
+    if (score >= 35)
+        return 'Creator';
+    return 'Raw';
+}
+// ═══════════════════════════════════════════════════════════════
+// §2 — Manifest Parser
+// ═══════════════════════════════════════════════════════════════
+function parseManifest(json) {
+    const data = JSON.parse(json);
+    if (!data.name || typeof data.cjpi !== 'number') {
+        throw new Error('Invalid CMPSBL manifest: missing name or cjpi');
+    }
+    return data;
+}
+function generateManifest(input) {
+    const cjpi = input.cjpi ?? 0;
+    return {
+        name: input.name,
+        tier: productTierFromScore(cjpi),
+        cjpi,
+        modules: input.modules ?? ['SYSTEM'],
+        exported: new Date().toISOString().slice(0, 10),
+        runtime: 'cmpsbl-mini-runtime-engine',
+        targets: input.targets ?? ['typescript'],
+        version: input.version ?? '1.0.0',
+        ...(input.category ? { category: input.category } : {}),
+        ...(input.fingerprint ? { fingerprint: input.fingerprint } : {}),
+        ...(input.source ? { source: input.source } : {}),
+    };
+}
+function buildDependencyGraph(nodes) {
+    const graph = new Map();
+    for (const node of nodes) {
+        graph.set(node.id, node.dependencies);
+    }
+    return graph;
+}
+function topologicalSort(nodes) {
+    const graph = buildDependencyGraph(nodes);
+    const visited = new Set();
+    const result = [];
+    function visit(id) {
+        if (visited.has(id))
+            return;
+        visited.add(id);
+        for (const dep of graph.get(id) ?? []) {
+            visit(dep);
+        }
+        result.push(id);
+    }
+    for (const node of nodes) {
+        visit(node.id);
+    }
+    return result;
+}
+class StateMachine {
+    constructor(config) {
+        this.current = config.initial;
+        this.transitions = config.transitions;
+    }
+    get state() { return this.current; }
+    send(event) {
+        const next = this.transitions[this.current]?.[event];
+        if (next)
+            this.current = next;
+        return this.current;
+    }
+    canSend(event) {
+        return this.transitions[this.current]?.[event] !== undefined;
+    }
+}
+exports.StateMachine = StateMachine;
+const primitiveRegistry = new Map();
+function registerPrimitive(name, handler) {
+    primitiveRegistry.set(name, handler);
+}
+async function executePrimitive(name, data, confidence) {
+    const handler = primitiveRegistry.get(name);
+    if (handler) {
+        return handler(data, confidence);
+    }
+    // Default fallback
+    return {
+        success: true,
+        output: { echo: data, primitive: name },
+        confidence: confidence * 0.8,
+        durationMs: 0,
+        handler: 'default-fallback',
+    };
+}
+async function executeChain(manifest, input, options) {
+    const start = Date.now();
+    let current = input;
+    let stagesCompleted = 0;
+    for (const mod of manifest.modules) {
+        try {
+            const result = await executePrimitive(mod, current, manifest.cjpiScore / 100);
+            if (result.success) {
+                current = typeof result.output === 'object' && result.output !== null
+                    ? result.output
+                    : { value: result.output };
+                stagesCompleted++;
+            }
+            else if (!options?.continueOnFailure) {
+                break;
+            }
+        }
+        catch {
+            if (!options?.continueOnFailure)
+                break;
+        }
+    }
+    return {
+        success: stagesCompleted === manifest.modules.length,
+        output: current,
+        confidence: manifest.cjpiScore / 100,
+        totalDurationMs: Date.now() - start,
+        stagesCompleted,
+        totalStages: manifest.modules.length,
+        runtimeMode: 'offline',
+        bridgeType: 'offline-fallback',
+    };
+}
+function createRuntime() {
+    return {
+        computeCJPI,
+        tierFromCJPI,
+        productTierFromScore,
+        parseManifest,
+        generateManifest,
+        topologicalSort,
+        registerPrimitive,
+        executePrimitive,
+        executeChain,
+        createStateMachine: (config) => new StateMachine(config),
+        version: '1.0.0',
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@cmpsbl/runtime",
+  "version": "1.0.0",
+  "description": "CMPSBL® Mini-Runtime™ Engine — CJPI scoring, auto-tiering, pipeline orchestration, and manifest parsing. Zero dependencies.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cmpsbl",
+    "runtime",
+    "cjpi",
+    "scoring",
+    "pipeline",
+    "orchestration"
+  ],
+  "author": "Kenneth E Sweet Jr <promptfluid@gmail.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cmpsbl/runtime"
+  },
+  "homepage": "https://cmpsbl.com",
+  "dependencies": {
+    "@cmpsbl/types": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.24",
+    "@types/lodash-es": "^4.17.12"
+  }
+}