Jules changes and some model renaming for clarity

scripts/apply-gallery-assignments.js

@@ -113,10 +113,17 @@ async function main(argv = process.argv.slice(2)) {
   const assignments = JSON.parse(await fs.promises.readFile(input, 'utf8'));
   console.log(`Loaded ${Object.keys(assignments).length} assignments`);
 
-  const compiledAssignments = Object.entries(assignments).map(([modelId, data]) => ({
-    modelId, data,
-    idPattern: new RegExp(`^id:\\s*["']?${modelId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}["']?\\s*$`, 'm')
-  }));
+  const compiledAssignments = [];
+  for (const [modelId, data] of Object.entries(assignments)) {
+    if (typeof modelId !== 'string' || modelId.length > 100) {
+      console.warn(`Skipping invalid modelId: ${modelId}`);
+      continue;
+    }
+    compiledAssignments.push({
+      modelId, data,
+      idPattern: new RegExp(`^id:\\s*["']?${modelId.replace(/[.*+?^${}()|[\]\\]/g, (match) => '\\' + match)}["']?\\s*$`, 'm')
+    });
+  }
 
   const SEARCH_ROOTS = ['Published', 'Examples', 'Tutorials'];
   const metadataFileArrays = SEARCH_ROOTS.map(searchRoot =>

scripts/backfill-metadata.js

@@ -58,29 +58,22 @@ async function findBnglFiles(dir, ignoreDirs = DEFAULT_IGNORE_DIRS) {
 }
 
 function extractMetadataFromComments(headerComments, metadata) {
-  if (headerComments.length === 0) return;
-
   for (const comment of headerComments) {
-    const nameMatch = comment.match(/(?:model|name)[:\s]+(.+)/i);
-    if (nameMatch && !metadata.name) {
-      metadata.name = nameMatch[1].trim();
-      continue;
-    }
-
-    const doiMatch = comment.match(/(?:doi|DOI)[:\s]+(10\.\S+)/i);
-    if (doiMatch) {
-      metadata.doi = doiMatch[1].trim();
+    const match = comment.match(/^([a-zA-Z0-9_-]+):\s*(.*)$/);
+    if (match) {
+      const key = match[1];
+      const val = match[2].trim();
+      if (key === 'tags') {
+        val.split(',').forEach(tag => metadata.tags.add(tag.trim()));
+      } else if (key === 'description') {
+        if (!metadata.description) metadata.description = val;
+      } else if (key === 'name') {
+        metadata.name = val;
+      } else if (key === 'doi') {
+        metadata.doi = val;
+      }
     }
   }
-
-  const nonParamComments = headerComments.filter(c =>
-    !c.match(/^[a-zA-Z_]\w*\s+changed\s+to/i) &&
-    !c.match(/(?:model|name)[:\s]+(.+)/i) &&
-    !c.match(/(?:doi|DOI)[:\s]+(10\.\S+)/i)
-  );
-  if (nonParamComments.length > 0 && !metadata.description) {
-    metadata.description = nonParamComments[0];
-  }
 }
 
 function processActionLine(trimmed, metadata) {

scripts/backfill-metadata.test.js

@@ -3,7 +3,7 @@ const assert = require('node:assert');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { parseBngl, generateMetadata, formatYamlValue, inferCategory, inferOrigin, extractMetadataFromComments } = require('./backfill-metadata.js');
+const { parseBngl, generateMetadata, formatYaml, formatYamlValue, inferCategory, inferOrigin, extractMetadataFromComments } = require('./backfill-metadata.js');
 
 test('backfill-metadata.js', async (t) => {
   let tmpDir;
@@ -22,7 +22,7 @@ test('backfill-metadata.js', async (t) => {
     const bnglContent = `
 # name: Test Model
 # doi: 10.1234/test
-# This is a description of the model.
+# description: This is a description of the model.
 # Some other comment
 
 begin model
@@ -245,6 +245,84 @@ end model
     assert.strictEqual(inferCategory(path.join(cwd, 'unknown_model')), 'other');
     assert.strictEqual(inferCategory(path.join(cwd, 'random', 'dir')), 'other');
   });
+
+  await t.test('inferOrigin - infers origin based on path', async (st) => {
+    const cwd = process.cwd();
+
+    await st.test('infers published for Published directory', () => {
+      assert.strictEqual(inferOrigin(path.join(cwd, 'Published', 'Model1')), 'published');
+      assert.strictEqual(inferOrigin(path.join(cwd, 'PUBLISHED', 'Model1')), 'published');
+    });
+
+    await st.test('infers ai-generated for Examples with AI prefix', () => {
+      assert.strictEqual(inferOrigin(path.join(cwd, 'Examples', 'AI-Generated-Model')), 'ai-generated');
+      assert.strictEqual(inferOrigin(path.join(cwd, 'Examples', 'aigenerated-Model')), 'ai-generated');
+      assert.strictEqual(inferOrigin(path.join(cwd, 'EXAMPLES', 'ai-generated-Model')), 'ai-generated');
+    });
+
+    await st.test('infers ai-generated for Examples without AI prefix (fallback)', () => {
+      assert.strictEqual(inferOrigin(path.join(cwd, 'Examples', 'Some-Model')), 'ai-generated');
+    });
+
+    await st.test('infers tutorial for Tutorials directory', () => {
+      assert.strictEqual(inferOrigin(path.join(cwd, 'Tutorials', 'Basic')), 'tutorial');
+      assert.strictEqual(inferOrigin(path.join(cwd, 'TUTORIALS', 'Basic')), 'tutorial');
+    });
+
+    await st.test('infers contributed when path contains contributed', () => {
+      assert.strictEqual(inferOrigin(path.join(cwd, 'SomeDir', 'Contributed-Model')), 'contributed');
+      assert.strictEqual(inferOrigin(path.join(cwd, 'SomeDir', 'CONTRIBUTED-Model')), 'contributed');
+    });
+
+    await st.test('infers test-case for unknown paths', () => {
+      assert.strictEqual(inferOrigin(path.join(cwd, 'Unknown', 'Dir')), 'test-case');
+    });
+  });
+});
+
+test('formatYaml', async (t) => {
+  await t.test('skips undefined and null values', async () => {
+    const obj = { a: 1, b: undefined, c: null, d: 'four' };
+    assert.strictEqual(formatYaml(obj), 'a: 1\nd: four\n');
+  });
+
+  await t.test('formats empty arrays', async () => {
+    const obj = { a: [] };
+    assert.strictEqual(formatYaml(obj), 'a: []\n');
+    assert.strictEqual(formatYaml(obj, 1), '  a: []\n');
+  });
+
+  await t.test('formats arrays of primitives', async () => {
+    const obj = { a: [1, 2, 3], b: ['one', 'two'], c: [true, false] };
+    const expected = 'a: [1, 2, 3]\nb: ["one", "two"]\nc: [true, false]\n';
+    assert.strictEqual(formatYaml(obj), expected);
+  });
+
+  await t.test('formats arrays of objects', async () => {
+    const obj = { a: [{ x: 1 }, { y: 2 }] };
+    const expected = 'a:\n  - x: 1\n  - y: 2\n';
+    assert.strictEqual(formatYaml(obj), expected);
+    const expectedIndented = '  a:\n    - x: 1\n    - y: 2\n';
+    assert.strictEqual(formatYaml(obj, 1), expectedIndented);
+  });
+
+  await t.test('formats mixed arrays', async () => {
+    const obj = { a: [1, { x: 1 }] };
+    const expected = 'a:\n  - 1\n  - x: 1\n';
+    assert.strictEqual(formatYaml(obj), expected);
+  });
+
+  await t.test('formats nested objects', async () => {
+    const obj = { a: { b: 1, c: { d: 2 } } };
+    const expected = 'a:\n  b: 1\n  c:\n    d: 2\n';
+    assert.strictEqual(formatYaml(obj), expected);
+  });
+
+  await t.test('formats basic properties', async () => {
+    const obj = { a: 1, b: true, c: 'string' };
+    const expected = 'a: 1\nb: true\nc: string\n';
+    assert.strictEqual(formatYaml(obj), expected);
+  });
 });
 
 test('formatYamlValue', async (t) => {
@@ -286,99 +364,75 @@ test('formatYamlValue', async (t) => {
   await t.test('handles null correctly', () => {
     assert.strictEqual(formatYamlValue(null), 'null\n');
   });
-
-  await t.test('inferOrigin - infers origin based on path', async (st) => {
-    const cwd = process.cwd();
-
-    await st.test('infers published for Published directory', () => {
-      assert.strictEqual(inferOrigin(path.join(cwd, 'Published', 'Model1')), 'published');
-    });
-
-    await st.test('infers ai-generated for Examples with AI prefix', () => {
-      assert.strictEqual(inferOrigin(path.join(cwd, 'Examples', 'AI-Generated-Model')), 'ai-generated');
-      assert.strictEqual(inferOrigin(path.join(cwd, 'Examples', 'aigenerated-Model')), 'ai-generated');
-    });
-
-    await st.test('infers ai-generated for Examples without AI prefix (fallback)', () => {
-      assert.strictEqual(inferOrigin(path.join(cwd, 'Examples', 'Some-Model')), 'ai-generated');
-    });
-
-    await st.test('infers tutorial for Tutorials directory', () => {
-      assert.strictEqual(inferOrigin(path.join(cwd, 'Tutorials', 'Basic')), 'tutorial');
-    });
-
-    await st.test('infers contributed when path contains contributed', () => {
-      assert.strictEqual(inferOrigin(path.join(cwd, 'SomeDir', 'Contributed-Model')), 'contributed');
-    });
-
-    await st.test('infers test-case for unknown paths', () => {
-      assert.strictEqual(inferOrigin(path.join(cwd, 'Unknown', 'Dir')), 'test-case');
-    });
-  });
 });
 
 test('extractMetadataFromComments', async (t) => {
-  await t.test('returns early if headerComments is empty', () => {
-    const metadata = { name: '', description: '', doi: '' };
+  await t.test('does nothing if headerComments is empty', () => {
+    const metadata = { name: '', description: '', doi: '', tags: new Set() };
     extractMetadataFromComments([], metadata);
-    assert.deepStrictEqual(metadata, { name: '', description: '', doi: '' });
+    assert.deepStrictEqual(metadata, { name: '', description: '', doi: '', tags: new Set() });
   });
 
-  await t.test('extracts model name from name: or model:', () => {
-    const metadata = { name: '' };
+  await t.test('extracts model name correctly and overwrites', () => {
+    const metadata = { name: 'Existing Name', description: '', doi: '', tags: new Set() };
     extractMetadataFromComments(['name: Test Model Name'], metadata);
     assert.strictEqual(metadata.name, 'Test Model Name');
-
-    const metadata2 = { name: '' };
-    extractMetadataFromComments(['model: Another Model'], metadata2);
-    assert.strictEqual(metadata2.name, 'Another Model');
   });
 
-  await t.test('does not overwrite existing name', () => {
-    const metadata = { name: 'Existing Name' };
-    extractMetadataFromComments(['name: New Name'], metadata);
-    assert.strictEqual(metadata.name, 'Existing Name');
-  });
-
-  await t.test('extracts DOI correctly', () => {
-    const metadata = { doi: '' };
+  await t.test('extracts DOI correctly and overwrites', () => {
+    const metadata = { name: '', description: '', doi: 'old.doi', tags: new Set() };
     extractMetadataFromComments(['doi: 10.1234/test.doi'], metadata);
     assert.strictEqual(metadata.doi, '10.1234/test.doi');
+  });
 
-    const metadata2 = { doi: '' };
-    extractMetadataFromComments(['DOI: 10.5678/another.doi'], metadata2);
-    assert.strictEqual(metadata2.doi, '10.5678/another.doi');
+  await t.test('extracts description and does not overwrite existing description', () => {
+    const metadata = { name: '', description: 'Existing Description', doi: '', tags: new Set() };
+    extractMetadataFromComments(['description: New Description'], metadata);
+    assert.strictEqual(metadata.description, 'Existing Description');
+
+    const metadata2 = { name: '', description: '', doi: '', tags: new Set() };
+    extractMetadataFromComments(['description: First Description', 'description: Second Description'], metadata2);
+    assert.strictEqual(metadata2.description, 'First Description');
   });
 
-  await t.test('extracts description from first non-parameter comment', () => {
-    const metadata = { description: '' };
-    const comments = [
-      'k1 changed to 2.0',
-      'This is the actual description',
-      'Some other comment'
-    ];
-    extractMetadataFromComments(comments, metadata);
-    assert.strictEqual(metadata.description, 'This is the actual description');
+  await t.test('extracts tags correctly and trims them', () => {
+    const metadata = { name: '', description: '', doi: '', tags: new Set(['existing-tag']) };
+    extractMetadataFromComments(['tags: tag1, tag2 , tag3'], metadata);
+    assert.deepStrictEqual(metadata.tags, new Set(['existing-tag', 'tag1', 'tag2', 'tag3']));
   });
 
-  await t.test('does not overwrite existing description', () => {
-    const metadata = { description: 'Existing Description' };
-    extractMetadataFromComments(['New Description'], metadata);
-    assert.strictEqual(metadata.description, 'Existing Description');
+  await t.test('ignores invalid or unhandled keys', () => {
+    const metadata = { name: 'Init', description: 'Init', doi: 'Init', tags: new Set() };
+    extractMetadataFromComments(['invalid-key: some value', 'unhandled: value'], metadata);
+    assert.strictEqual(metadata.name, 'Init');
+    assert.strictEqual(metadata.description, 'Init');
+    assert.strictEqual(metadata.doi, 'Init');
+    assert.deepStrictEqual(metadata.tags, new Set());
+  });
+
+  await t.test('ignores comments not matching regex', () => {
+    const metadata = { name: '', description: '', doi: '', tags: new Set() };
+    extractMetadataFromComments(['just some regular comment', 'no colon here', 'name : bad format'], metadata);
+    assert.strictEqual(metadata.name, '');
+    assert.strictEqual(metadata.description, '');
+    assert.strictEqual(metadata.doi, '');
+    assert.deepStrictEqual(metadata.tags, new Set());
   });
 
   await t.test('extracts everything together', () => {
-    const metadata = { name: '', description: '', doi: '' };
+    const metadata = { name: '', description: '', doi: '', tags: new Set() };
     const comments = [
-      'model: Full Model',
+      'name: Full Model',
       'doi: 10.9999/full',
-      'rate_constant changed to 5',
-      'A description of the full model',
-      'Another note'
+      'description: A description of the full model',
+      'tags: t1, t2',
+      'ignored: this is ignored',
+      'just some text'
     ];
     extractMetadataFromComments(comments, metadata);
     assert.strictEqual(metadata.name, 'Full Model');
     assert.strictEqual(metadata.doi, '10.9999/full');
     assert.strictEqual(metadata.description, 'A description of the full model');
+    assert.deepStrictEqual(metadata.tags, new Set(['t1', 't2']));
   });
 });

scripts/generate-gallery.js

@@ -110,9 +110,20 @@ function parseYamlSimple(content) {
   return result;
 }
 
-function extractModelIds(metadataFile, metadata) {
+async function extractModelIds(metadataFile, metadata) {
   const modelDir = path.dirname(metadataFile);
-  const bnglFiles = fs.readdirSync(modelDir, { withFileTypes: true })
+  let entries;
+  try {
+    entries = await fs.promises.readdir(modelDir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      entries = [];
+    } else {
+      throw err;
+    }
+  }
+
+  const bnglFiles = entries
     .filter(e => e.isFile() && e.name.endsWith('.bngl'))
     .map(e => e.name)
     .sort();
@@ -156,7 +167,7 @@ async function main(argv = process.argv.slice(2)) {
       const content = await fs.promises.readFile(metadataFile, 'utf8');
       const metadata = parseMetadataYaml(content);
 
-      const modelIds = extractModelIds(metadataFile, metadata);
+      const modelIds = await extractModelIds(metadataFile, metadata);
       if (modelIds.length === 0) continue;
 
       const tags = Array.isArray(metadata.tags) ? metadata.tags : [];

scripts/generate-gallery.test.js

@@ -235,35 +235,35 @@ test('extractModelIds', async (t) => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
-  await t.test('returns metadata id if is collection', () => {
+  await t.test('returns metadata id if is collection', async () => {
     const metadataPath = path.join(tmpDir, 'metadata.yaml');
     fs.writeFileSync(metadataPath, '');
-    const result = extractModelIds(metadataPath, { id: 'coll_1', collection: true });
+    const result = await extractModelIds(metadataPath, { id: 'coll_1', collection: true });
     assert.deepStrictEqual(result, ['coll_1']);
   });
 
-  await t.test('returns metadata id if it exists and bngl files are present', () => {
+  await t.test('returns metadata id if it exists and bngl files are present', async () => {
     const metadataPath = path.join(tmpDir, 'metadata.yaml');
     fs.writeFileSync(metadataPath, '');
     fs.writeFileSync(path.join(tmpDir, 'model.bngl'), '');
 
-    const result = extractModelIds(metadataPath, { id: 'meta_id' });
+    const result = await extractModelIds(metadataPath, { id: 'meta_id' });
     assert.deepStrictEqual(result, ['meta_id']);
   });
 
-  await t.test('returns filename of bngl if no metadata id is present', () => {
+  await t.test('returns filename of bngl if no metadata id is present', async () => {
     const metadataPath = path.join(tmpDir, 'metadata.yaml');
     fs.writeFileSync(metadataPath, '');
     fs.writeFileSync(path.join(tmpDir, 'my_model.bngl'), '');
 
-    const result = extractModelIds(metadataPath, {});
+    const result = await extractModelIds(metadataPath, {});
     assert.deepStrictEqual(result, ['my_model']);
   });
 
-  await t.test('returns empty array if no bngl files are present (and not a collection)', () => {
+  await t.test('returns empty array if no bngl files are present (and not a collection)', async () => {
     const metadataPath = path.join(tmpDir, 'metadata.yaml');
     fs.writeFileSync(metadataPath, '');
-    const result = extractModelIds(metadataPath, { id: 'meta_id' });
+    const result = await extractModelIds(metadataPath, { id: 'meta_id' });
     assert.deepStrictEqual(result, []);
   });
 });