@trohde/earos 1.0.0

package/schemas/rubric.schema.json

@@ -0,0 +1,383 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://raw.githubusercontent.com/ThomasRohde/EAROS/main/standard/schemas/rubric.schema.json",
+  "title": "EAROS Rubric/Profile/Overlay Schema",
+  "type": "object",
+  "required": [
+    "rubric_id",
+    "version",
+    "kind",
+    "title",
+    "artifact_type",
+    "dimensions",
+    "scoring",
+    "outputs"
+  ],
+  "properties": {
+    "rubric_id": {
+      "type": "string",
+      "description": "Unique identifier e.g. EAROS-CORE-002"
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$"
+    },
+    "kind": {
+      "type": "string",
+      "enum": [
+        "core_rubric",
+        "profile",
+        "overlay"
+      ]
+    },
+    "title": {
+      "type": "string"
+    },
+    "status": {
+      "type": "string",
+      "enum": [
+        "draft",
+        "candidate",
+        "approved",
+        "deprecated"
+      ]
+    },
+    "effective_date": {
+      "type": "string",
+      "format": "date"
+    },
+    "next_review_date": {
+      "type": "string",
+      "format": "date"
+    },
+    "owner": {
+      "type": "string"
+    },
+    "artifact_type": {
+      "type": "string"
+    },
+    "inherits": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Rubric IDs this extends"
+    },
+    "purpose": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "stakeholders": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "viewpoints": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "applicability": {
+      "type": "object",
+      "description": "Conditions under which this rubric applies"
+    },
+    "design_method": {
+      "type": "string",
+      "enum": [
+        "decision_centred",
+        "viewpoint_centred",
+        "lifecycle_centred",
+        "risk_centred",
+        "pattern_library"
+      ],
+      "description": "v2.0: Which of the five profile design methods was used"
+    },
+    "dimensions": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "name",
+          "criteria"
+        ],
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "weight": {
+            "type": "number",
+            "minimum": 0
+          },
+          "criteria": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "required": [
+                "id",
+                "question",
+                "metric_type",
+                "scale",
+                "required_evidence",
+                "scoring_guide"
+              ],
+              "properties": {
+                "id": {
+                  "type": "string"
+                },
+                "question": {
+                  "type": "string"
+                },
+                "description": {
+                  "type": "string"
+                },
+                "metric_type": {
+                  "type": "string",
+                  "enum": [
+                    "ordinal",
+                    "binary",
+                    "count",
+                    "presence",
+                    "coverage"
+                  ]
+                },
+                "scale": {
+                  "oneOf": [
+                    {
+                      "type": "array"
+                    },
+                    {
+                      "type": "object"
+                    },
+                    {
+                      "type": "string"
+                    }
+                  ]
+                },
+                "weight": {
+                  "type": "number"
+                },
+                "gate": {
+                  "oneOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "object",
+                      "required": [
+                        "enabled",
+                        "severity"
+                      ],
+                      "properties": {
+                        "enabled": {
+                          "type": "boolean"
+                        },
+                        "severity": {
+                          "type": "string",
+                          "enum": [
+                            "advisory",
+                            "major",
+                            "critical"
+                          ]
+                        },
+                        "failure_effect": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  ]
+                },
+                "required_evidence": {
+                  "type": "array",
+                  "items": {
+                    "oneOf": [
+                      {
+                        "type": "string"
+                      },
+                      {
+                        "type": "object"
+                      }
+                    ]
+                  }
+                },
+                "scoring_guide": {
+                  "type": "object",
+                  "additionalProperties": {
+                    "type": "string"
+                  }
+                },
+                "anti_patterns": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "remediation_hints": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "examples": {
+                  "type": "object",
+                  "properties": {
+                    "good": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    },
+                    "bad": {
+                      "type": "array",
+                      "items": {
+                        "type": "string"
+                      }
+                    }
+                  },
+                  "description": "v2.0: Positive and negative examples for AI disambiguation"
+                },
+                "decision_tree": {
+                  "type": "string",
+                  "description": "v2.0: IF/THEN disambiguation logic for AI agents"
+                },
+                "tags": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "scoring": {
+      "type": "object",
+      "required": [
+        "scale",
+        "method",
+        "thresholds"
+      ],
+      "properties": {
+        "scale": {
+          "type": "string"
+        },
+        "agent_scale": {
+          "type": "string",
+          "description": "v2.0: Optional collapsed scale for pure agent evaluation"
+        },
+        "method": {
+          "type": "string"
+        },
+        "thresholds": {
+          "type": "object"
+        },
+        "na_policy": {
+          "type": "string"
+        },
+        "confidence_policy": {
+          "type": "string"
+        },
+        "reliability_targets": {
+          "type": "object",
+          "description": "v2.0: Inter-rater reliability targets",
+          "properties": {
+            "binary_agreement": {
+              "type": "string"
+            },
+            "ordinal_kappa": {
+              "type": "string"
+            },
+            "overall_correlation": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
+    "outputs": {
+      "type": "object",
+      "required": [
+        "require_evidence_refs",
+        "require_confidence",
+        "require_actions"
+      ],
+      "properties": {
+        "require_evidence_refs": {
+          "type": "boolean"
+        },
+        "require_confidence": {
+          "type": "boolean"
+        },
+        "require_actions": {
+          "type": "boolean"
+        },
+        "require_evidence_class": {
+          "type": "boolean",
+          "description": "v2.0: Require observed/inferred/external classification"
+        },
+        "require_evidence_anchors": {
+          "type": "boolean",
+          "description": "v2.0: RULERS-style citation+quotation"
+        },
+        "formats": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "agent_evaluation": {
+      "type": "object",
+      "description": "v2.0: Agent-specific evaluation configuration",
+      "properties": {
+        "dag_steps": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "rubric_locked": {
+          "type": "boolean"
+        },
+        "rubric_lock_version": {
+          "type": "string"
+        },
+        "calibration_method": {
+          "type": "string",
+          "enum": [
+            "rulers_wasserstein",
+            "llm_rubric_network",
+            "manual"
+          ]
+        }
+      }
+    },
+    "calibration": {
+      "type": "object"
+    },
+    "change_log": {
+      "type": "array",
+      "items": {
+        "type": "object"
+      }
+    },
+    "metadata": {
+      "type": "object"
+    }
+  }
+}

package/serve.js

@@ -0,0 +1,238 @@
+/**
+ * EaROS standalone Express server.
+ * Serves the pre-built React app from dist/ and provides the API endpoints.
+ */
+import express from 'express';
+import { createServer } from 'http';
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+import open from 'open';
+import { exportToDocx, exportRubricToDocx, exportEvaluationToDocx } from './export-docx.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function findRepoRoot() {
+    const cwd = process.cwd();
+    if (existsSync(resolve(cwd, 'earos.manifest.yaml')))
+        return cwd;
+    // Dev fallback: two levels above tools/editor/
+    const devRoot = resolve(__dirname, '../..');
+    if (existsSync(resolve(devRoot, 'earos.manifest.yaml')))
+        return devRoot;
+    return cwd;
+}
+function safeRepoPath(repoRoot, rawPath) {
+    const decoded = decodeURIComponent(rawPath);
+    const abs = resolve(repoRoot, decoded);
+    if (!abs.startsWith(repoRoot))
+        return null;
+    return abs;
+}
+function findAvailablePort(preferred) {
+    return new Promise((resolvePort) => {
+        const probe = createServer();
+        probe.listen(preferred, () => {
+            const port = probe.address().port;
+            probe.close(() => resolvePort(port));
+        });
+        probe.on('error', () => {
+            // Port in use — let OS assign a random one
+            const fallback = createServer();
+            fallback.listen(0, () => {
+                const port = fallback.address().port;
+                fallback.close(() => resolvePort(port));
+            });
+        });
+    });
+}
+export async function startServer(fileArg) {
+    const REPO_ROOT = findRepoRoot();
+    const distDir = resolve(__dirname, 'dist');
+    if (!existsSync(distDir)) {
+        console.error('dist/ not found. Run: npm run build');
+        process.exit(1);
+    }
+    const app = express();
+    app.use(express.json({ limit: '25mb' }));
+    // GET /api/manifest  or  GET /api/files
+    const manifestHandler = (_req, res) => {
+        const manifestPath = resolve(REPO_ROOT, 'earos.manifest.yaml');
+        if (!existsSync(manifestPath)) {
+            res.status(404).json({ error: 'earos.manifest.yaml not found — run: earos manifest' });
+        }
+        else {
+            res.json(yaml.load(readFileSync(manifestPath, 'utf8')));
+        }
+    };
+    app.get('/api/manifest', manifestHandler);
+    app.get('/api/files', manifestHandler);
+    // GET /api/evaluations — recursively scan for evaluation files
+    function findEvaluationFiles(baseDir, prefix) {
+        const found = [];
+        if (!existsSync(baseDir))
+            return found;
+        try {
+            for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+                if (entry.isDirectory()) {
+                    found.push(...findEvaluationFiles(resolve(baseDir, entry.name), `${prefix}${entry.name}/`));
+                }
+                else if (entry.name.endsWith('.evaluation.yaml') || entry.name === 'evaluation.yaml') {
+                    found.push({ path: `${prefix}${entry.name}`, name: entry.name });
+                }
+            }
+        }
+        catch { /* skip unreadable dirs */ }
+        return found;
+    }
+    app.get('/api/evaluations', (_req, res) => {
+        const files = [];
+        for (const dir of ['examples', 'evaluations']) {
+            files.push(...findEvaluationFiles(resolve(REPO_ROOT, dir), `${dir}/`));
+        }
+        res.json({ files });
+    });
+    // GET /api/evaluations/summary — lightweight metadata per evaluation file
+    app.get('/api/evaluations/summary', (_req, res) => {
+        const files = [];
+        for (const dir of ['examples', 'evaluations']) {
+            files.push(...findEvaluationFiles(resolve(REPO_ROOT, dir), `${dir}/`));
+        }
+        const summaries = files.map((f) => {
+            const absPath = resolve(REPO_ROOT, f.path);
+            try {
+                const data = yaml.load(readFileSync(absPath, 'utf8'));
+                return {
+                    path: f.path,
+                    name: f.name,
+                    overall_status: data?.overall_status ?? undefined,
+                    overall_score: data?.overall_score ?? undefined,
+                    evaluation_date: data?.evaluation_date ?? undefined,
+                    title: data?.artifact_ref?.title ?? data?.artifact_id ?? f.name.replace(/\.evaluation\.yaml$|\.yaml$/, ''),
+                };
+            }
+            catch {
+                return { path: f.path, name: f.name, title: f.name };
+            }
+        });
+        res.json({ summaries });
+    });
+    // GET /api/file/:path  (path may contain slashes)
+    app.get('/api/file/*', (req, res) => {
+        const rawPath = req.params[0];
+        const absPath = safeRepoPath(REPO_ROOT, rawPath);
+        if (!absPath) {
+            res.status(403).json({ error: 'Path outside repo root' });
+            return;
+        }
+        if (!existsSync(absPath)) {
+            res.status(404).json({ error: `File not found: ${rawPath}` });
+            return;
+        }
+        try {
+            res.json(yaml.load(readFileSync(absPath, 'utf8')));
+        }
+        catch (e) {
+            res.status(500).json({ error: String(e) });
+        }
+    });
+    // POST /api/file/:path
+    app.post('/api/file/*', (req, res) => {
+        const rawPath = req.params[0];
+        const absPath = safeRepoPath(REPO_ROOT, rawPath);
+        if (!absPath) {
+            res.status(403).json({ error: 'Path outside repo root' });
+            return;
+        }
+        try {
+            const content = yaml.dump(req.body, { lineWidth: 120, noRefs: true });
+            writeFileSync(absPath, content, 'utf8');
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: String(e) });
+        }
+    });
+    // POST /api/export/docx  — generate a Word document from artifact JSON
+    app.post('/api/export/docx', async (req, res) => {
+        try {
+            const payload = req.body;
+            const artifactData = payload?.artifactData ?? payload;
+            const renderedDiagrams = payload?.artifactData && payload.renderedDiagrams && typeof payload.renderedDiagrams === 'object'
+                ? payload.renderedDiagrams
+                : undefined;
+            if (!artifactData || typeof artifactData !== 'object') {
+                res.status(400).json({ error: 'Request body must be artifact JSON' });
+                return;
+            }
+            const buf = await exportToDocx(artifactData, renderedDiagrams);
+            const title = artifactData?.metadata?.title?.replace(/[^a-z0-9]/gi, '-').toLowerCase() ?? 'artifact';
+            res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+            res.setHeader('Content-Disposition', `attachment; filename="${title}.docx"`);
+            res.send(buf);
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            if (message.startsWith('Missing browser-rendered diagrams for export:')) {
+                res.status(400).json({ error: message });
+                return;
+            }
+            res.status(500).json({ error: message });
+        }
+    });
+    // POST /api/export/docx/rubric  — generate a Word document from rubric JSON
+    app.post('/api/export/docx/rubric', async (req, res) => {
+        try {
+            const data = req.body;
+            if (!data || typeof data !== 'object') {
+                res.status(400).json({ error: 'Request body must be rubric JSON' });
+                return;
+            }
+            const buf = await exportRubricToDocx(data);
+            const title = data?.title?.replace(/[^a-z0-9]/gi, '-').toLowerCase() ?? 'rubric';
+            res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+            res.setHeader('Content-Disposition', `attachment; filename="${title}.docx"`);
+            res.send(buf);
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    // POST /api/export/docx/evaluation  — generate a Word document from evaluation JSON
+    app.post('/api/export/docx/evaluation', async (req, res) => {
+        try {
+            const data = req.body;
+            if (!data || typeof data !== 'object') {
+                res.status(400).json({ error: 'Request body must be evaluation JSON' });
+                return;
+            }
+            const buf = await exportEvaluationToDocx(data);
+            const title = data?.artifact_ref?.title?.replace(/[^a-z0-9]/gi, '-').toLowerCase() ?? 'evaluation';
+            res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+            res.setHeader('Content-Disposition', `attachment; filename="${title}-assessment.docx"`);
+            res.send(buf);
+        }
+        catch (e) {
+            res.status(500).json({ error: e instanceof Error ? e.message : String(e) });
+        }
+    });
+    // Unknown API routes
+    app.all('/api/*', (_req, res) => {
+        res.status(404).json({ error: 'Unknown API route' });
+    });
+    // Workspace icon assets
+    app.use('/icons', express.static(resolve(REPO_ROOT, 'icons')));
+    // Static files — served after API routes
+    app.use(express.static(distDir));
+    // SPA fallback
+    app.get('*', (_req, res) => {
+        res.sendFile(resolve(distDir, 'index.html'));
+    });
+    const port = await findAvailablePort(process.env.PORT ? parseInt(process.env.PORT, 10) : 3000);
+    app.listen(port, () => {
+        const url = fileArg
+            ? `http://localhost:${port}?file=${encodeURIComponent(fileArg)}`
+            : `http://localhost:${port}`;
+        console.log(`EaROS Editor → ${url}`);
+        open(url);
+    });
+}