@trohde/earos 1.0.0

package/init.js

@@ -0,0 +1,353 @@
+import { cpSync, copyFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, resolve, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+import JSZip from 'jszip';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ─── Alias specs per cloud ────────────────────────────────────────────────────
+const AWS_ALIAS_SPECS = [
+    { alias: 'api-gateway', tokenVariants: [['api', 'gateway']], preferredPathTokens: ['service'] },
+    { alias: 'aws-cloud', tokenVariants: [['aws', 'cloud']], preferredPathTokens: ['group'] },
+    { alias: 'cloudfront', tokenVariants: [['cloudfront'], ['cloud', 'front']], preferredPathTokens: ['service'] },
+    { alias: 'cloudtrail', tokenVariants: [['cloudtrail'], ['cloud', 'trail']], preferredPathTokens: ['service'] },
+    { alias: 'cloudwatch', tokenVariants: [['cloudwatch'], ['cloud', 'watch']], preferredPathTokens: ['service'] },
+    { alias: 'cognito', tokenVariants: [['cognito']], preferredPathTokens: ['service'] },
+    { alias: 'data-firehose', tokenVariants: [['firehose'], ['kinesis', 'data', 'firehose']], preferredPathTokens: ['service'] },
+    { alias: 'dynamodb', tokenVariants: [['dynamodb'], ['dynamo', 'db']], preferredPathTokens: ['service'] },
+    { alias: 'ecs', tokenVariants: [['ecs'], ['elastic', 'container', 'service']], preferredPathTokens: ['service'] },
+    { alias: 'eks', tokenVariants: [['eks'], ['elastic', 'kubernetes']], preferredPathTokens: ['service'] },
+    { alias: 'elasticache', tokenVariants: [['elasticache']], preferredPathTokens: ['service'] },
+    { alias: 'eventbridge', tokenVariants: [['eventbridge'], ['event', 'bridge']], preferredPathTokens: ['service'] },
+    { alias: 'kinesis', tokenVariants: [['kinesis']], preferredPathTokens: ['service'] },
+    { alias: 'lambda', tokenVariants: [['lambda']], preferredPathTokens: ['service'] },
+    { alias: 'nat-gateway', tokenVariants: [['nat', 'gateway']], preferredPathTokens: ['resource'] },
+    { alias: 'private-subnet', tokenVariants: [['private', 'subnet']], preferredPathTokens: ['resource'] },
+    { alias: 'rds', tokenVariants: [['rds'], ['relational', 'database']], preferredPathTokens: ['service'] },
+    { alias: 'redshift', tokenVariants: [['redshift']], preferredPathTokens: ['service'] },
+    { alias: 'route53', tokenVariants: [['route', '53'], ['route53']], preferredPathTokens: ['service'] },
+    { alias: 's3', tokenVariants: [['s3'], ['simple', 'storage', 'service']], preferredPathTokens: ['service'] },
+    { alias: 'ses', tokenVariants: [['ses'], ['simple', 'email', 'service']], preferredPathTokens: ['service'] },
+    { alias: 'sns', tokenVariants: [['sns'], ['simple', 'notification', 'service']], preferredPathTokens: ['service'] },
+    { alias: 'sqs', tokenVariants: [['sqs'], ['simple', 'queue', 'service']], preferredPathTokens: ['service'] },
+    { alias: 'step-functions', tokenVariants: [['step', 'functions']], preferredPathTokens: ['service'] },
+    { alias: 'vpc', tokenVariants: [['vpc'], ['virtual', 'private', 'cloud']], preferredPathTokens: ['service'] },
+    { alias: 'waf', tokenVariants: [['waf'], ['web', 'application', 'firewall']], preferredPathTokens: ['service'] },
+    { alias: 'xray', tokenVariants: [['xray'], ['x', 'ray']], preferredPathTokens: ['service'] },
+];
+const AZURE_ALIAS_SPECS = [
+    { alias: 'api-management', tokenVariants: [['api', 'management']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'app-service', tokenVariants: [['app', 'service'], ['app', 'services']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'application-gateway', tokenVariants: [['application', 'gateway']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'blob-storage', tokenVariants: [['blob', 'block'], ['blob', 'storage']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'cognitive-services', tokenVariants: [['cognitive', 'services']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'container-instances', tokenVariants: [['container', 'instances']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'cosmos-db', tokenVariants: [['cosmos', 'db'], ['cosmosdb']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'entra-id', tokenVariants: [['entra', 'id'], ['active', 'directory']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'event-grid', tokenVariants: [['event', 'grid']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'event-hubs', tokenVariants: [['event', 'hubs']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'front-door', tokenVariants: [['front', 'door']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'functions', tokenVariants: [['functions']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'key-vault', tokenVariants: [['key', 'vaults'], ['key', 'vault']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'kubernetes-service', tokenVariants: [['kubernetes', 'service'], ['aks']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'load-balancer', tokenVariants: [['load', 'balancer']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'logic-apps', tokenVariants: [['logic', 'apps']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'monitor', tokenVariants: [['monitor']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'redis-cache', tokenVariants: [['redis', 'cache'], ['cache', 'redis']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'service-bus', tokenVariants: [['service', 'bus']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'sql-database', tokenVariants: [['sql', 'database']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'storage-accounts', tokenVariants: [['storage', 'accounts']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'synapse-analytics', tokenVariants: [['synapse', 'analytics'], ['synapse']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'virtual-machine', tokenVariants: [['virtual', 'machine']], preferredPathTokens: ['icon', 'service'] },
+    { alias: 'virtual-network', tokenVariants: [['virtual', 'network']], preferredPathTokens: ['icon', 'service'] },
+];
+const GCP_ALIAS_SPECS = [
+    { alias: 'api-gateway', tokenVariants: [['api', 'gateway']], preferredPathTokens: [] },
+    { alias: 'app-engine', tokenVariants: [['app', 'engine']], preferredPathTokens: [] },
+    { alias: 'bigquery', tokenVariants: [['bigquery'], ['big', 'query']], preferredPathTokens: [] },
+    { alias: 'bigtable', tokenVariants: [['bigtable'], ['big', 'table']], preferredPathTokens: [] },
+    { alias: 'cloud-armor', tokenVariants: [['cloud', 'armor']], preferredPathTokens: [] },
+    { alias: 'cloud-cdn', tokenVariants: [['cloud', 'cdn']], preferredPathTokens: [] },
+    { alias: 'cloud-dns', tokenVariants: [['cloud', 'dns']], preferredPathTokens: [] },
+    { alias: 'cloud-functions', tokenVariants: [['cloud', 'functions']], preferredPathTokens: [] },
+    { alias: 'cloud-load-balancing', tokenVariants: [['cloud', 'load', 'balancing'], ['load', 'balancing']], preferredPathTokens: [] },
+    { alias: 'cloud-logging', tokenVariants: [['cloud', 'logging']], preferredPathTokens: [] },
+    { alias: 'cloud-monitoring', tokenVariants: [['cloud', 'monitoring']], preferredPathTokens: [] },
+    { alias: 'cloud-run', tokenVariants: [['cloud', 'run']], preferredPathTokens: [] },
+    { alias: 'cloud-sql', tokenVariants: [['cloud', 'sql']], preferredPathTokens: [] },
+    { alias: 'cloud-storage', tokenVariants: [['cloud', 'storage']], preferredPathTokens: [] },
+    { alias: 'compute-engine', tokenVariants: [['compute', 'engine']], preferredPathTokens: [] },
+    { alias: 'dataflow', tokenVariants: [['dataflow'], ['data', 'flow']], preferredPathTokens: [] },
+    { alias: 'dataproc', tokenVariants: [['dataproc'], ['data', 'proc']], preferredPathTokens: [] },
+    { alias: 'firestore', tokenVariants: [['firestore'], ['fire', 'store']], preferredPathTokens: [] },
+    { alias: 'gke', tokenVariants: [['kubernetes', 'engine'], ['gke']], preferredPathTokens: [] },
+    { alias: 'iam', tokenVariants: [['iam'], ['identity', 'access']], preferredPathTokens: [] },
+    { alias: 'memorystore', tokenVariants: [['memorystore'], ['memory', 'store']], preferredPathTokens: [] },
+    { alias: 'pub-sub', tokenVariants: [['pub', 'sub'], ['pubsub']], preferredPathTokens: [] },
+    { alias: 'spanner', tokenVariants: [['spanner']], preferredPathTokens: [] },
+    { alias: 'vpc', tokenVariants: [['virtual', 'private', 'cloud'], ['vpc']], preferredPathTokens: [] },
+];
+// ─── URL resolution per cloud ─────────────────────────────────────────────────
+async function resolveAwsIconPackageUrl() {
+    const envUrl = process.env.EAROS_AWS_ICON_PACKAGE_URL;
+    if (envUrl)
+        return envUrl;
+    const pageUrl = process.env.EAROS_AWS_ICON_PAGE_URL ?? 'https://aws.amazon.com/architecture/icons/';
+    const response = await fetch(pageUrl, { redirect: 'follow' });
+    if (!response.ok) {
+        throw new Error(`Unable to load AWS icon page: HTTP ${response.status}`);
+    }
+    const html = await response.text();
+    const button2UrlMatch = html.match(/"button2URL":"([^"]+\.zip)"/i);
+    if (button2UrlMatch?.[1]) {
+        return new URL(button2UrlMatch[1], response.url).toString();
+    }
+    const anchorMatch = html.match(/<a[^>]+href="([^"]+)"[^>]*>\s*Icon package\s*<\/a>/i);
+    if (anchorMatch?.[1]) {
+        return new URL(anchorMatch[1], response.url).toString();
+    }
+    const zipMatches = [...html.matchAll(/https:\/\/d1\.awsstatic\.com\/[^"'\s>]+\.zip/gi)].map((match) => match[0]);
+    const candidateUrl = zipMatches.find((url) => /asset|icon/i.test(url)) ?? zipMatches[0];
+    if (candidateUrl)
+        return candidateUrl;
+    throw new Error(`Could not find the AWS icon package link on ${response.url}`);
+}
+async function resolveAzureIconPackageUrl() {
+    const envUrl = process.env.EAROS_AZURE_ICON_PACKAGE_URL;
+    if (envUrl)
+        return envUrl;
+    const pageUrl = process.env.EAROS_AZURE_ICON_PAGE_URL ?? 'https://learn.microsoft.com/en-us/azure/architecture/icons/';
+    const response = await fetch(pageUrl, { redirect: 'follow' });
+    if (!response.ok) {
+        throw new Error(`Unable to load Azure icon page: HTTP ${response.status}`);
+    }
+    const html = await response.text();
+    // Look for the download link — typically an azureedge.net or azure.com hosted ZIP
+    const downloadMatch = html.match(/href="([^"]+\.zip)"/i);
+    if (downloadMatch?.[1]) {
+        return new URL(downloadMatch[1], response.url).toString();
+    }
+    // Fallback: look for any ZIP URL in the page content
+    const zipMatches = [...html.matchAll(/https:\/\/[^"'\s>]+\.zip/gi)].map((match) => match[0]);
+    const candidateUrl = zipMatches.find((url) => /icon/i.test(url)) ?? zipMatches[0];
+    if (candidateUrl)
+        return candidateUrl;
+    throw new Error(`Could not find the Azure icon package link on ${response.url}`);
+}
+async function resolveGcpIconPackageUrl() {
+    const envUrl = process.env.EAROS_GCP_ICON_PACKAGE_URL;
+    if (envUrl)
+        return envUrl;
+    // GCP's icon page is JS-rendered, so we try the known stable URL first
+    const knownUrls = [
+        'https://cloud.google.com/static/icons/files/google-cloud-icons.zip',
+    ];
+    for (const url of knownUrls) {
+        try {
+            const response = await fetch(url, { method: 'HEAD', redirect: 'follow' });
+            if (response.ok)
+                return url;
+        }
+        catch {
+            // try next
+        }
+    }
+    // Fallback: try to scrape the page
+    const pageUrl = process.env.EAROS_GCP_ICON_PAGE_URL ?? 'https://cloud.google.com/icons';
+    const response = await fetch(pageUrl, { redirect: 'follow' });
+    if (!response.ok) {
+        throw new Error(`Unable to load GCP icon page: HTTP ${response.status}`);
+    }
+    const html = await response.text();
+    const zipMatches = [...html.matchAll(/https:\/\/[^"'\s>]+\.zip/gi)].map((match) => match[0]);
+    const candidateUrl = zipMatches.find((url) => /icon/i.test(url)) ?? zipMatches[0];
+    if (candidateUrl)
+        return candidateUrl;
+    throw new Error(`Could not find the GCP icon package link on ${pageUrl}`);
+}
+// ─── Cloud package configs ────────────────────────────────────────────────────
+const ICON_PACKAGES = [
+    {
+        name: 'AWS',
+        aliasDir: 'aws',
+        pageUrl: 'https://aws.amazon.com/architecture/icons/',
+        packageUrlEnvVar: 'EAROS_AWS_ICON_PACKAGE_URL',
+        aliasSpecs: AWS_ALIAS_SPECS,
+        resolveUrl: resolveAwsIconPackageUrl,
+        extraScore: (entry) => entry.fileTokens.has('arch') ? 5 : 0,
+    },
+    {
+        name: 'Azure',
+        aliasDir: 'azure',
+        pageUrl: 'https://learn.microsoft.com/en-us/azure/architecture/icons/',
+        packageUrlEnvVar: 'EAROS_AZURE_ICON_PACKAGE_URL',
+        aliasSpecs: AZURE_ALIAS_SPECS,
+        resolveUrl: resolveAzureIconPackageUrl,
+    },
+    {
+        name: 'GCP',
+        aliasDir: 'gcp',
+        pageUrl: 'https://cloud.google.com/icons',
+        packageUrlEnvVar: 'EAROS_GCP_ICON_PACKAGE_URL',
+        aliasSpecs: GCP_ALIAS_SPECS,
+        resolveUrl: resolveGcpIconPackageUrl,
+        filterEntry: (normalizedPath) => {
+            // GCP ZIPs contain SVG/, PNG/, and other dirs — only extract SVGs
+            const lower = normalizedPath.toLowerCase();
+            return lower.endsWith('.svg') || lower.endsWith('.pdf') || lower.endsWith('.txt') || lower.endsWith('.md');
+        },
+    },
+];
+// ─── Generic icon download infrastructure ─────────────────────────────────────
+function tokenizeForMatch(value) {
+    return new Set(value.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(/\s+/).filter(Boolean));
+}
+function normalizeZipEntryPath(entryName) {
+    const normalized = entryName.replace(/\\/g, '/').replace(/^\/+/, '');
+    const segments = normalized.split('/').filter(Boolean);
+    if (!segments.length || segments.some((segment) => segment === '..' || segment.includes(':'))) {
+        return null;
+    }
+    return segments.join('/');
+}
+function buildExtractedIconEntry(normalizedPath, outputPath) {
+    return {
+        normalizedPath,
+        outputPath,
+        pathTokens: tokenizeForMatch(normalizedPath),
+        fileTokens: tokenizeForMatch(basename(normalizedPath)),
+    };
+}
+function matchesVariant(entry, tokenVariant) {
+    return tokenVariant.every((token) => entry.pathTokens.has(token) || entry.fileTokens.has(token));
+}
+function scoreAliasCandidate(entry, spec, config) {
+    const matchedVariant = spec.tokenVariants.find((tokenVariant) => matchesVariant(entry, tokenVariant));
+    if (!matchedVariant)
+        return Number.NEGATIVE_INFINITY;
+    let score = matchedVariant.length * 10;
+    if (spec.preferredPathTokens.length && spec.preferredPathTokens.every((token) => entry.pathTokens.has(token))) {
+        score += 40;
+    }
+    if (config.extraScore)
+        score += config.extraScore(entry);
+    // Prefer shorter paths (more specific matches)
+    score -= entry.normalizedPath.length / 1000;
+    return score;
+}
+function createIconAliases(iconsDir, extractedEntries, config) {
+    const aliasDir = join(iconsDir, config.aliasDir);
+    mkdirSync(aliasDir, { recursive: true });
+    let aliasCount = 0;
+    const missingAliases = [];
+    for (const spec of config.aliasSpecs) {
+        const bestCandidate = extractedEntries
+            .map((entry) => ({ entry, score: scoreAliasCandidate(entry, spec, config) }))
+            .filter((candidate) => Number.isFinite(candidate.score))
+            .sort((left, right) => right.score - left.score)[0];
+        if (!bestCandidate) {
+            missingAliases.push(spec.alias);
+            continue;
+        }
+        copyFileSync(bestCandidate.entry.outputPath, join(aliasDir, `${spec.alias}.svg`));
+        aliasCount += 1;
+    }
+    return { aliasCount, missingAliases };
+}
+async function downloadIconPackage(targetDir, config) {
+    console.log(`Resolving ${config.name} icon package URL...`);
+    const packageUrl = await config.resolveUrl();
+    console.log(`Downloading ${config.name} icons from ${packageUrl}`);
+    const response = await fetch(packageUrl, { redirect: 'follow' });
+    if (!response.ok) {
+        throw new Error(`Unable to download ${config.name} icon package: HTTP ${response.status}`);
+    }
+    const zip = await JSZip.loadAsync(await response.arrayBuffer());
+    const iconsDir = join(targetDir, 'icons');
+    mkdirSync(iconsDir, { recursive: true });
+    let fileCount = 0;
+    const extractedEntries = [];
+    for (const [entryName, zipEntry] of Object.entries(zip.files)) {
+        if (zipEntry.dir)
+            continue;
+        const normalizedEntryPath = normalizeZipEntryPath(entryName);
+        if (!normalizedEntryPath)
+            continue;
+        if (config.filterEntry && !config.filterEntry(normalizedEntryPath))
+            continue;
+        const outputPath = join(iconsDir, normalizedEntryPath);
+        mkdirSync(dirname(outputPath), { recursive: true });
+        writeFileSync(outputPath, await zipEntry.async('nodebuffer'));
+        fileCount += 1;
+        if (normalizedEntryPath.toLowerCase().endsWith('.svg')) {
+            extractedEntries.push(buildExtractedIconEntry(normalizedEntryPath, outputPath));
+        }
+    }
+    const { aliasCount, missingAliases } = createIconAliases(iconsDir, extractedEntries, config);
+    return { name: config.name, packageUrl, fileCount, aliasCount, missingAliases };
+}
+// ─── Main ─────────────────────────────────────────────────────────────────────
+export async function initWorkspace(targetDir, options = {}) {
+    const target = resolve(process.cwd(), targetDir);
+    // When compiled, init.js sits in tools/editor/ alongside assets/
+    const assetsDir = join(__dirname, 'assets', 'init');
+    const workspaceExists = existsSync(join(target, 'earos.manifest.yaml'));
+    if (!existsSync(assetsDir)) {
+        console.error('Asset directory not found. Run npm run build first.');
+        process.exit(1);
+    }
+    if (workspaceExists && !options.downloadIcons) {
+        console.error(`${target} already contains an EaROS workspace (earos.manifest.yaml exists).`);
+        process.exit(1);
+    }
+    if (!workspaceExists) {
+        mkdirSync(target, { recursive: true });
+        cpSync(assetsDir, target, { recursive: true });
+    }
+    else {
+        console.log(`EaROS workspace already exists at ${target}; downloading icons only.`);
+    }
+    let iconDownloadSummary = '';
+    if (options.downloadIcons) {
+        const results = [];
+        for (const config of ICON_PACKAGES) {
+            try {
+                const result = await downloadIconPackage(target, config);
+                results.push(result);
+                if (result.missingAliases.length) {
+                    console.warn(`  Missing ${config.name} icon aliases: ${result.missingAliases.join(', ')}`);
+                }
+            }
+            catch (error) {
+                console.error(`  Failed to download ${config.name} icons: ${error.message}`);
+            }
+        }
+        if (results.length) {
+            const totalFiles = results.reduce((sum, r) => sum + r.fileCount, 0);
+            const totalAliases = results.reduce((sum, r) => sum + r.aliasCount, 0);
+            const aliasLines = results.map((r) => `  icons/${r.name.toLowerCase()}/           ${r.name} Mermaid icon aliases (${r.aliasCount} files)`).join('\n');
+            iconDownloadSummary = `  icons/                 Architecture icon packages (${totalFiles} files)\n${aliasLines}\n`;
+        }
+    }
+    const isCurrentDir = targetDir === '.' || targetDir === './';
+    const cdStep = isCurrentDir ? '' : `  cd ${targetDir}\n`;
+    console.log(`
+✓ EaROS workspace initialized at: ${target}
+
+Contents:
+  core/                  Core meta-rubric (universal foundation)
+  profiles/              Artifact-specific profiles (5 included)
+  overlays/              Cross-cutting concern overlays (3 included)
+  standard/schemas/      JSON schemas for validation
+  templates/             Blank templates for new profiles and evaluations
+  evaluations/           Your evaluation records go here
+  calibration/           Calibration artifacts and results
+  .agents/skills/        All 10 EaROS skills for any AI coding agent
+${iconDownloadSummary}  earos.manifest.yaml    File inventory (single source of truth)
+  AGENTS.md              Project guide for AI agents (agent-agnostic)
+
+Next steps:
+${cdStep}  earos                  Open the editor
+  earos validate core/core-meta-rubric.yaml   Validate a file
+  earos manifest check   Verify manifest integrity
+`);
+}

package/manifest-cli.mjs

@@ -0,0 +1,207 @@
+/**
+ * EAROS Manifest CLI (compiled JS — do not edit; source is manifest-cli.ts)
+ *
+ * Usage (via bin.js):
+ *   earos manifest              # regenerate
+ *   earos manifest add <file>   # add entry
+ *   earos manifest check        # verify consistency
+ *
+ * EAROS_REPO_ROOT env var is set by bin.js to the detected repo root.
+ */
+
+import { readFileSync, writeFileSync, readdirSync, existsSync } from 'fs'
+import { resolve, dirname } from 'path'
+import { fileURLToPath } from 'url'
+import yaml from 'js-yaml'
+
+const __dir = dirname(fileURLToPath(import.meta.url))
+const REPO_ROOT = process.env.EAROS_REPO_ROOT ?? resolve(__dir, '../..')
+const MANIFEST_PATH = resolve(REPO_ROOT, 'earos.manifest.yaml')
+
+const SCAN_DIRS = {
+  core: 'core',
+  profiles: 'profiles',
+  overlays: 'overlays',
+}
+
+function readYaml(absPath) {
+  try {
+    return yaml.load(readFileSync(absPath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function scanDir(dir) {
+  const absDir = resolve(REPO_ROOT, dir)
+  if (!existsSync(absDir)) return []
+  return readdirSync(absDir)
+    .filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
+    .map((f) => {
+      const data = readYaml(resolve(absDir, f))
+      if (!data) return null
+      return {
+        path: `${dir}/${f}`,
+        rubric_id: data.rubric_id ?? undefined,
+        title: data.title ?? undefined,
+        artifact_type: data.artifact_type ?? undefined,
+        status: data.status ?? undefined,
+      }
+    })
+    .filter(Boolean)
+}
+
+function buildManifest() {
+  return {
+    kind: 'manifest',
+    version: '2.0.0',
+    generated: new Date().toISOString().slice(0, 10),
+    core: scanDir('core'),
+    profiles: scanDir('profiles'),
+    overlays: scanDir('overlays'),
+    schemas: [
+      { path: 'standard/schemas/rubric.schema.json', validates: ['core_rubric', 'profile', 'overlay'] },
+      { path: 'standard/schemas/evaluation.schema.json', validates: ['evaluation'] },
+    ],
+    templates: [
+      { path: 'templates/new-profile.template.yaml', purpose: 'scaffold for new profiles' },
+      { path: 'templates/evaluation-record.template.yaml', purpose: 'blank evaluation record' },
+      { path: 'templates/reference-architecture/Reference_Architecture_Template_v2.docx', purpose: 'author template for reference architectures' },
+    ],
+    scoring_tools: [
+      { path: 'tools/scoring-sheets/EAROS_Scoring_Sheet_v2.xlsx', purpose: 'general-purpose manual scoring (current)' },
+      { path: 'tools/scoring-sheets/EAROS_Scoring_Sheet.xlsx', purpose: 'general-purpose manual scoring (legacy)' },
+      { path: 'tools/scoring-sheets/EAROS_RefArch_Scoring_Sheet.xlsx', purpose: 'reference architecture scoring' },
+    ],
+  }
+}
+
+function writeManifest(manifest) {
+  writeFileSync(MANIFEST_PATH, yaml.dump(manifest, { lineWidth: 120 }), 'utf8')
+}
+
+function loadManifest() {
+  if (!existsSync(MANIFEST_PATH)) return null
+  return readYaml(MANIFEST_PATH)
+}
+
+// ─── CLI dispatch ──────────────────────────────────────────────────────────────
+
+const subArgs = process.argv.slice(2)
+const subCmd = subArgs[0]
+
+if (!subCmd || subCmd === 'generate') {
+  const manifest = buildManifest()
+  writeManifest(manifest)
+  const counts = `core:${manifest.core?.length ?? 0} profiles:${manifest.profiles?.length ?? 0} overlays:${manifest.overlays?.length ?? 0}`
+  console.log(`✓ earos.manifest.yaml generated (${counts})`)
+  process.exit(0)
+}
+
+if (subCmd === 'add') {
+  const filePath = subArgs[1]
+  if (!filePath) {
+    console.error('Usage: earos manifest add <path/to/file.yaml>')
+    process.exit(1)
+  }
+  const manifest = loadManifest()
+  if (!manifest) {
+    console.error('No earos.manifest.yaml found. Run `earos manifest` first.')
+    process.exit(1)
+  }
+  const absPath = resolve(REPO_ROOT, filePath)
+  const data = readYaml(absPath)
+  if (!data) {
+    console.error(`Cannot read or parse: ${filePath}`)
+    process.exit(1)
+  }
+  const entry = {
+    path: filePath,
+    rubric_id: data.rubric_id,
+    title: data.title,
+    artifact_type: data.artifact_type,
+    status: data.status,
+  }
+  const kind = data.kind
+  if (kind === 'core_rubric') {
+    manifest.core = manifest.core ?? []
+    const idx = manifest.core.findIndex((e) => e.path === filePath)
+    if (idx >= 0) manifest.core[idx] = entry
+    else manifest.core.push(entry)
+  } else if (kind === 'profile') {
+    manifest.profiles = manifest.profiles ?? []
+    const idx = manifest.profiles.findIndex((e) => e.path === filePath)
+    if (idx >= 0) manifest.profiles[idx] = entry
+    else manifest.profiles.push(entry)
+  } else if (kind === 'overlay') {
+    manifest.overlays = manifest.overlays ?? []
+    const idx = manifest.overlays.findIndex((e) => e.path === filePath)
+    if (idx >= 0) manifest.overlays[idx] = entry
+    else manifest.overlays.push(entry)
+  } else {
+    console.error(`Unsupported kind: ${kind ?? '(none)'}. Expected core_rubric, profile, or overlay.`)
+    process.exit(1)
+  }
+  manifest.generated = new Date().toISOString().slice(0, 10)
+  writeManifest(manifest)
+  console.log(`✓ Added ${filePath} (${kind}, ${entry.rubric_id ?? 'no rubric_id'}) to manifest`)
+  process.exit(0)
+}
+
+if (subCmd === 'check') {
+  const manifest = loadManifest()
+  if (!manifest) {
+    console.error('No earos.manifest.yaml found. Run `earos manifest` first.')
+    process.exit(1)
+  }
+  const errors = []
+  const warnings = []
+
+  const allEntries = [
+    ...(manifest.core ?? []),
+    ...(manifest.profiles ?? []),
+    ...(manifest.overlays ?? []),
+  ]
+  for (const entry of allEntries) {
+    const absPath = resolve(REPO_ROOT, entry.path)
+    if (!existsSync(absPath)) {
+      errors.push(`MISSING on disk: ${entry.path}`)
+    } else {
+      const data = readYaml(absPath)
+      if (data?.rubric_id !== entry.rubric_id) {
+        warnings.push(`${entry.path}: rubric_id mismatch — manifest: ${entry.rubric_id}, file: ${data?.rubric_id}`)
+      }
+    }
+  }
+
+  for (const [section, dir] of Object.entries(SCAN_DIRS)) {
+    const absDir = resolve(REPO_ROOT, dir)
+    if (!existsSync(absDir)) continue
+    const files = readdirSync(absDir).filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'))
+    for (const f of files) {
+      const relPath = `${dir}/${f}`
+      const sectionData = manifest[section]
+      if (!sectionData?.some((e) => e.path === relPath)) {
+        errors.push(`NOT IN MANIFEST: ${relPath}`)
+      }
+    }
+  }
+
+  if (errors.length === 0 && warnings.length === 0) {
+    console.log('✓ Manifest is consistent with filesystem')
+    process.exit(0)
+  }
+  if (errors.length > 0) {
+    console.error(`✗ ${errors.length} error(s):`)
+    for (const e of errors) console.error(`  ERROR: ${e}`)
+  }
+  if (warnings.length > 0) {
+    console.warn(`⚠ ${warnings.length} warning(s):`)
+    for (const w of warnings) console.warn(`  WARN: ${w}`)
+  }
+  process.exit(errors.length > 0 ? 1 : 0)
+}
+
+console.error(`Unknown manifest subcommand: ${subCmd}`)
+console.error('Usage: earos manifest [generate|add <file>|check]')
+process.exit(1)

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@trohde/earos",
+  "version": "1.0.0",
+  "description": "Schema-driven editor and CLI for EaROS architecture assessment rubrics and evaluations",
+  "type": "module",
+  "bin": {
+    "earos": "./bin.js"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -p tsconfig.server.json && tsc && vite build && npm run build:assets",
+    "build:assets": "node scripts/build-assets.js",
+    "postbuild": "node scripts/postbuild.mjs",
+    "preview": "vite preview",
+    "prepublishOnly": "npm run build",
+    "prepare": "cd ../.. && git config core.hooksPath tools || true",
+    "release:patch": "npm version patch --no-git-tag-version && npm publish --access public",
+    "release:minor": "npm version minor --no-git-tag-version && npm publish --access public",
+    "release:major": "npm version major --no-git-tag-version && npm publish --access public",
+    "version:patch": "npm version patch --no-git-tag-version",
+    "version:minor": "npm version minor --no-git-tag-version",
+    "version:major": "npm version major --no-git-tag-version"
+  },
+  "files": [
+    "dist/",
+    "bin.js",
+    "serve.js",
+    "init.js",
+    "export-docx.js",
+    "manifest-cli.mjs",
+    "schemas/",
+    "assets/",
+    "README.md"
+  ],
+  "keywords": [
+    "earos",
+    "architecture",
+    "rubric",
+    "assessment",
+    "evaluation",
+    "yaml",
+    "editor"
+  ],
+  "author": "Thomas Rohde <rohde.thomas@gmail.com>",
+  "license": "CC-BY-4.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ThomasRohde/EAROS"
+  },
+  "homepage": "https://github.com/ThomasRohde/EAROS/tree/master/tools/editor",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "ajv-formats": "^3.0.1",
+    "docx": "^9.6.1",
+    "express": "^4.22.1",
+    "js-yaml": "^4.1.0",
+    "jszip": "^3.10.1",
+    "mermaid": "^11.13.0",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@emotion/react": "^11.11.4",
+    "@emotion/styled": "^11.11.0",
+    "@jsonforms/core": "^3.3.0",
+    "@jsonforms/material-renderers": "^3.3.0",
+    "@jsonforms/react": "^3.3.0",
+    "@mui/icons-material": "^7.0.0",
+    "@mui/material": "^7.0.0",
+    "@types/express": "^4.17.25",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.19.37",
+    "@types/react": "^18.3.1",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.2.1",
+    "esbuild": "^0.27.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.4.5",
+    "vite": "^5.2.8"
+  }
+}