@trohde/earos 1.0.0

package/assets/init/standard/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/assets/init/templates/evaluation-record.template.yaml

@@ -0,0 +1,58 @@
+kind: evaluation
+artifact_id: "[ART-YYYY-NNNN]"
+artifact_type: "[artifact_type]"
+artifact_version: "[version]"
+rubric_id: "[EAROS-XXX-NNN]"
+rubric_version: "[version]"
+profiles_applied:
+  - "[profile_id]"
+overlays_applied:
+  - "[overlay_id]"
+evaluated_by:
+  - role: evaluator
+    actor: "[human | agent]"
+    identity: "[name or model]"
+  - role: challenger
+    actor: "[human | agent]"
+    identity: "[name or model]"
+evaluation_mode: "[human | agent | hybrid]"
+evaluation_date: "YYYY-MM-DD"
+dag_execution:
+  steps_completed:
+    - structural_validation
+    - content_extraction
+    - criterion_scoring
+    - cross_reference_validation
+    - dimension_aggregation
+    - challenge_pass
+    - calibration
+    - status_determination
+  rubric_lock_version: "[version]"
+  calibration_applied: true
+criterion_results:
+  - criterion_id: "[CRIT-ID]"
+    score: 0
+    confidence: low
+    confidence_reason: "[why]"
+    evidence_sufficiency: none
+    evidence_class: observed
+    evidence_refs:
+      - section: "[section name]"
+        page: 0
+        quotation: "[quoted text]"
+    rationale: "[explanation]"
+    evidence_gaps:
+      - "[gap]"
+    recommended_actions:
+      - "[action]"
+dimension_results:
+  - dimension_id: "[DIM-ID]"
+    weighted_score: 0.0
+gate_failures: []
+overall_status: "[pass | conditional_pass | rework_required | reject | not_reviewable]"
+overall_score: 0.0
+confidence: low
+recommended_actions:
+  - "[action]"
+decision_summary: "[summary]"
+challenger_notes: "[findings from challenge pass]"

package/assets/init/templates/new-profile.template.yaml

@@ -0,0 +1,65 @@
+rubric_id: EAROS-PROF-XXX
+version: 1.0.0
+kind: profile
+title: "[Artifact Type] Profile"
+status: draft
+effective_date: "YYYY-MM-DD"
+owner: "[Owner]"
+artifact_type: "[artifact_type]"
+inherits:
+  - EAROS-CORE-002
+design_method: "[decision_centred | viewpoint_centred | lifecycle_centred | risk_centred | pattern_library]"
+purpose:
+  - "[purpose]"
+stakeholders:
+  - "[stakeholder]"
+
+dimensions:
+  - id: "[DIM-ID]"
+    name: "[Dimension Name]"
+    description: "[What this dimension evaluates]"
+    weight: 1.0
+    criteria:
+      - id: "[CRIT-ID]"
+        question: "[The question this criterion asks]"
+        description: "[Detailed description]"
+        metric_type: ordinal
+        scale: [0, 1, 2, 3, 4, "N/A"]
+        gate: false
+        required_evidence:
+          - "[evidence type]"
+        scoring_guide:
+          "0": "[Absent description]"
+          "1": "[Weak description]"
+          "2": "[Partial description]"
+          "3": "[Good description]"
+          "4": "[Strong description]"
+        anti_patterns:
+          - "[common failure]"
+        examples:
+          good:
+            - "[Example of strong evidence]"
+          bad:
+            - "[Example of weak evidence]"
+        decision_tree: "[IF/THEN logic for AI disambiguation]"
+        remediation_hints:
+          - "[How to improve]"
+
+scoring:
+  scale: 0-4 ordinal plus N/A
+  method: gates_first_then_weighted_average
+  thresholds:
+    pass: No critical gate failure, overall >= 3.2, and no dimension < 2.0
+    conditional_pass: No critical gate failure and overall 2.4-3.19
+    rework_required: Overall < 2.4
+    reject: Critical gate failure
+
+outputs:
+  require_evidence_refs: true
+  require_confidence: true
+  require_actions: true
+  require_evidence_class: true
+
+calibration:
+  required_before_production: true
+  minimum_examples: 3

package/bin.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from 'fs'
+import { resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import { spawnSync } from 'child_process'
+import yaml from 'js-yaml'
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const args = process.argv.slice(2)
+
+/** Find the EAROS repo root: cwd if it has earos.manifest.yaml, else dev fallback. */
+function findRepoRoot() {
+  const cwd = process.cwd()
+  if (existsSync(resolve(cwd, 'earos.manifest.yaml'))) return cwd
+  const devRoot = resolve(__dirname, '../..')
+  if (existsSync(resolve(devRoot, 'earos.manifest.yaml'))) return devRoot
+  return cwd
+}
+
+/** Find schemas dir: bundled with package first, then repo fallback. */
+function findSchemasDir() {
+  const bundled = resolve(__dirname, 'schemas')
+  if (existsSync(bundled)) return bundled
+  return resolve(__dirname, '../../standard/schemas')
+}
+
+// ─── validate command ─────────────────────────────────────────────────────────
+
+async function validateFile(filePath) {
+  const absPath = resolve(filePath)
+  let content
+  try {
+    content = readFileSync(absPath, 'utf8')
+  } catch {
+    console.error(`Cannot read file: ${absPath}`)
+    process.exit(1)
+  }
+
+  let data
+  try {
+    data = yaml.load(content)
+  } catch (e) {
+    console.error(`YAML parse error: ${e.message}`)
+    process.exit(1)
+  }
+
+  const kind = data?.kind
+  const schemasDir = findSchemasDir()
+  const schemaFile =
+    kind === 'evaluation'
+      ? resolve(schemasDir, 'evaluation.schema.json')
+      : kind === 'artifact'
+        ? resolve(schemasDir, 'artifact.schema.json')
+        : resolve(schemasDir, 'rubric.schema.json')
+
+  const rawSchema = JSON.parse(readFileSync(schemaFile, 'utf8'))
+  // Strip $schema/$id so AJV v8 doesn't try to load the draft-2020 meta-schema
+  const { $schema: _s, $id: _i, ...schema } = rawSchema
+  const ajv = new Ajv({ strict: false, allErrors: true })
+  addFormats(ajv)
+  const validate = ajv.compile(schema)
+  const valid = validate(data)
+
+  if (valid) {
+    console.log(`✓ ${filePath} is valid (kind: ${kind ?? 'unknown'})`)
+    process.exit(0)
+  } else {
+    console.error(`✗ ${filePath} — ${validate.errors.length} error(s):`)
+    for (const err of validate.errors) {
+      console.error(`  ${err.instancePath || '(root)'} ${err.message}`)
+    }
+    process.exit(1)
+  }
+}
+
+// ─── CLI dispatch ──────────────────────────────────────────────────────────────
+
+if (args[0] === '--help' || args[0] === '-h') {
+  console.log(`earos — EAROS editor and CLI
+
+Usage:
+  earos                             Open the editor in your browser
+  earos <file.yaml>                 Open the editor with a file pre-loaded
+  earos init [dir] [--icons]        Scaffold a new EAROS workspace (default: current dir)
+  earos validate <file.yaml>        Validate a rubric or evaluation YAML (exit 0/1)
+  earos export <file.yaml>          Export artifact YAML as Word document (.docx)
+  earos manifest                    Regenerate earos.manifest.yaml
+  earos manifest add <file>         Add a file to the manifest
+  earos manifest check              Verify manifest matches filesystem
+  earos dev                         Start Vite dev server (development only)`)
+  process.exit(0)
+} else if (args[0] === 'export') {
+  // Export artifact YAML → Word document
+  if (!args[1]) {
+    console.error('Usage: earos export <file.yaml>')
+    process.exit(1)
+  }
+  const inputPath = resolve(args[1])
+  if (!existsSync(inputPath)) {
+    console.error(`File not found: ${inputPath}`)
+    process.exit(1)
+  }
+  let exportContent
+  try { exportContent = readFileSync(inputPath, 'utf8') } catch (e) {
+    console.error(`Cannot read file: ${e.message}`)
+    process.exit(1)
+  }
+  let artifactData
+  try { artifactData = yaml.load(exportContent) } catch (e) {
+    console.error(`YAML parse error: ${e.message}`)
+    process.exit(1)
+  }
+  if (artifactData?.kind !== 'artifact') {
+    console.error('File does not appear to be an artifact (expected kind: artifact)')
+    process.exit(1)
+  }
+  const { exportToDocx } = await import('./export-docx.js')
+  const outputPath = inputPath.replace(/\.(yaml|yml)$/i, '') + '.docx'
+  console.log('Rendering diagrams and building Word document…')
+  try {
+    const { writeFileSync } = await import('fs')
+    const buf = await exportToDocx(artifactData)
+    writeFileSync(outputPath, buf)
+    console.log(`✓ Exported → ${outputPath}`)
+  } catch (e) {
+    console.error(`Export failed: ${e.message}`)
+    process.exit(1)
+  }
+} else if (args[0] === 'init') {
+  const initArgs = args.slice(1)
+  let targetDir = '.'
+  let downloadIcons = false
+
+  for (const arg of initArgs) {
+    if (arg === '--icons') {
+      downloadIcons = true
+      continue
+    }
+    if (arg.startsWith('--')) {
+      console.error(`Unknown init option: ${arg}`)
+      process.exit(1)
+    }
+    if (targetDir === '.') {
+      targetDir = arg
+      continue
+    }
+    console.error('Usage: earos init [dir] [--icons]')
+    process.exit(1)
+  }
+
+  const { initWorkspace } = await import('./init.js')
+  await initWorkspace(targetDir, { downloadIcons })
+} else if (args[0] === 'validate') {
+  if (!args[1]) {
+    console.error('Usage: earos validate <file.yaml>')
+    process.exit(1)
+  }
+  await validateFile(args[1])
+} else if (args[0] === 'manifest') {
+  const manifestCli = resolve(__dirname, 'manifest-cli.mjs')
+  const result = spawnSync(process.execPath, [manifestCli, ...args.slice(1)], {
+    stdio: 'inherit',
+    env: { ...process.env, EAROS_REPO_ROOT: findRepoRoot() },
+  })
+  if (result.error) {
+    console.error('Failed to run manifest CLI:', result.error.message)
+    process.exit(1)
+  }
+  process.exit(result.status ?? 0)
+} else if (args[0] === 'dev') {
+  // Development only — starts Vite HMR server (requires devDependencies)
+  const result = spawnSync('npx', ['vite'], {
+    stdio: 'inherit',
+    cwd: __dirname,
+    shell: true,
+  })
+  if (result.error) {
+    console.error('Failed to start Vite. Ensure devDependencies are installed: npm install')
+    process.exit(1)
+  }
+  process.exit(result.status ?? 0)
+} else {
+  // Default: start the standalone Express server
+  const { startServer } = await import('./serve.js')
+  await startServer(args[0])
+}

package/dist/assets/_basePickBy-BVu6YmSW.js

@@ -0,0 +1 @@
+import{e as x,c as O,g as m,k as P,h as p,j as w,l as c,m as A,n as I,t as N,o as _}from"./_baseUniq-CWRzQDz_.js";import{aV as g,aC as $,aW as E,aX as F,aY as M,aZ as b,a_ as B,a$ as T,b0 as y,b1 as S}from"./index-BFFITMT8.js";var C=/\s/;function G(n){for(var r=n.length;r--&&C.test(n.charAt(r)););return r}var H=/^\s+/;function L(n){return n&&n.slice(0,G(n)+1).replace(H,"")}var o=NaN,R=/^[-+]0x[0-9a-f]+$/i,W=/^0b[01]+$/i,X=/^0o[0-7]+$/i,Y=parseInt;function q(n){if(typeof n=="number")return n;if(x(n))return o;if(g(n)){var r=typeof n.valueOf=="function"?n.valueOf():n;n=g(r)?r+"":r}if(typeof n!="string")return n===0?n:+n;n=L(n);var t=W.test(n);return t||X.test(n)?Y(n.slice(2),t?2:8):R.test(n)?o:+n}var v=1/0,z=17976931348623157e292;function K(n){if(!n)return n===0?n:0;if(n=q(n),n===v||n===-v){var r=n<0?-1:1;return r*z}return n===n?n:0}function Z(n){var r=K(n),t=r%1;return r===r?t?r-t:r:0}function fn(n){var r=n==null?0:n.length;return r?O(n):[]}var l=Object.prototype,D=l.hasOwnProperty,dn=$(function(n,r){n=Object(n);var t=-1,i=r.length,a=i>2?r[2]:void 0;for(a&&E(r[0],r[1],a)&&(i=1);++t<i;)for(var f=r[t],e=F(f),s=-1,d=e.length;++s<d;){var u=e[s],h=n[u];(h===void 0||M(h,l[u])&&!D.call(n,u))&&(n[u]=f[u])}return n});function un(n){var r=n==null?0:n.length;return r?n[r-1]:void 0}function J(n){return function(r,t,i){var a=Object(r);if(!b(r)){var f=m(t);r=P(r),t=function(s){return f(a[s],s,a)}}var e=n(r,t,i);return e>-1?a[f?r[e]:e]:void 0}}var Q=Math.max;function U(n,r,t){var i=n==null?0:n.length;if(!i)return-1;var a=t==null?0:Z(t);return a<0&&(a=Q(i+a,0)),p(n,m(r),a)}var hn=J(U);function V(n,r){var t=-1,i=b(n)?Array(n.length):[];return w(n,function(a,f,e){i[++t]=r(a,f,e)}),i}function gn(n,r){var t=B(n)?c:V;return t(n,m(r))}var j=Object.prototype,k=j.hasOwnProperty;function nn(n,r){return n!=null&&k.call(n,r)}function mn(n,r){return n!=null&&A(n,r,nn)}function rn(n,r){return n<r}function tn(n,r,t){for(var i=-1,a=n.length;++i<a;){var f=n[i],e=r(f);if(e!=null&&(s===void 0?e===e&&!x(e):t(e,s)))var s=e,d=f}return d}function on(n){return n&&n.length?tn(n,T,rn):void 0}function an(n,r,t,i){if(!g(n))return n;r=I(r,n);for(var a=-1,f=r.length,e=f-1,s=n;s!=null&&++a<f;){var d=N(r[a]),u=t;if(d==="__proto__"||d==="constructor"||d==="prototype")return n;if(a!=e){var h=s[d];u=void 0,u===void 0&&(u=g(h)?h:y(r[a+1])?[]:{})}S(s,d,u),s=s[d]}return n}function vn(n,r,t){for(var i=-1,a=r.length,f={};++i<a;){var e=r[i],s=_(n,e);t(s,e)&&an(f,I(e,n),s)}return f}export{rn as a,tn as b,V as c,vn as d,on as e,fn as f,hn as g,mn as h,dn as i,Z as j,un as l,gn as m,K as t};