@gregiteen/ssss-cli 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.11.2] - 2026-10-19
+### Added
+- `parseFrontmatter(fm, { strict: true })` throws a `SyntaxError` on lines that
+  are not `key: value`, orphaned indentation, and malformed quoted or inline
+  values, so hosts such as Total Recall can report unreadable files. The default
+  stays lenient. Strict mode accepts all 30,518 files in 57 Total Recall vaults.
+
 ## [0.11.1] - 2026-10-19
 ### Fixed
 - The frontmatter parser (`@gregiteen/ssss-cli/frontmatter`) now reads the YAML

package/VERSION

@@ -1 +1 @@
-0.11.1
+0.11.2

package/conformance/reference-bundle.ucw.json

@@ -106,7 +106,7 @@
     "file_count": 14,
     "provenance": {
       "content_hash": "sha256:7febd673938a3dc04c068e0bf08097a9783c09e612606d2df9a4db8dcb8907f5",
-      "exporter": "@gregiteen/ssss-cli@0.11.1"
+      "exporter": "@gregiteen/ssss-cli@0.11.2"
     }
   },
   "files": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gregiteen/ssss-cli",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "CLI tools and the reference engine for the Structured Semantic Syntax System",
   "main": "src/engine.mjs",
   "exports": {

package/scripts/check-frontmatter.mjs

@@ -89,6 +89,16 @@ check('single-line files with literal \\n are repaired on read', () => {
   assert.equal(parseDocument('---\nk: a\\nb\n---\n').data.k, 'a\\nb');
 });
 
+check('strict mode throws on malformed YAML that lenient mode skips', () => {
+  const bad = ': : :\nnot: [valid\n';
+  assert.doesNotThrow(() => parseFrontmatter(bad));
+  assert.throws(() => parseFrontmatter(bad, { strict: true }), SyntaxError);
+  assert.throws(() => parseFrontmatter('k: "open\nj: 1\n', { strict: true }), SyntaxError);
+  assert.throws(() => parseFrontmatter('a: 1\n  b: 2\n', { strict: true }), SyntaxError);
+  assert.deepEqual(parseFrontmatter('a: [1, 2]\nb: {c: d}\n', { strict: true }), { a: [1, 2], b: { c: 'd' } });
+  assert.doesNotThrow(() => parseFrontmatter(bad)); // strict does not leak into later calls
+});
+
 check('serialize → parse round-trips tricky values', () => {
   const data = {
     'allowed-tools': ['Read', 'Bash'],

package/src/frontmatter.mjs

@@ -170,16 +170,24 @@ function parseFlow(src) {
   return value;
 }
 
+// Set by parseFrontmatter(fm, { strict: true }): malformed input throws instead of
+// being skipped or kept as raw text.
+let strictMode = false;
+
 function coerce(raw) {
   const v = raw.trim();
   if (v === '') return '';
   if (v[0] === '"' || v[0] === "'") {
     const end = findClosingQuote(v);
     if (end > 0 && /^\s*(#.*)?$/.test(v.slice(end + 1))) return unquote(v.slice(0, end + 1));
+    if (strictMode) throw new SyntaxError(`Malformed quoted value: ${v.slice(0, 60)}`);
     return v;
   }
   if (v[0] === '[' || v[0] === '{') {
-    try { return parseFlow(v); } catch { return v; }
+    try { return parseFlow(v); } catch (err) {
+      if (strictMode) throw new SyntaxError(`Malformed inline value: ${v.slice(0, 60)}`);
+      return v;
+    }
   }
   return coercePlain(stripComment(v));
 }
@@ -214,6 +222,7 @@ function readScalar(lines, i, keyIndent, rest) {
     if (!line.trim()) { blanks++; j++; continue; }
     if (countIndent(line) <= keyIndent) break;
     if (!inline && line.trim().startsWith('#')) break;
+    if (strictMode && !inline && splitKeyValue(line.trim())) throw new SyntaxError(`Unexpected key in a wrapped value: ${line.trim().slice(0, 60)}`);
     const piece = inline ? line.trim() : stripComment(line.trim());
     text += blanks ? '\n'.repeat(blanks) + piece : ` ${piece}`;
     blanks = 0;
@@ -278,9 +287,17 @@ function parseMap(lines, start, indent) {
     if (!line.trim() || line.trim().startsWith('#')) { i++; continue; }
     const currentIndent = countIndent(line);
     if (currentIndent < indent) break;
-    if (currentIndent > indent) { i++; continue; }
+    if (currentIndent > indent) {
+      if (strictMode) throw new SyntaxError(`Unexpected indentation: ${line.trim().slice(0, 60)}`);
+      i++;
+      continue;
+    }
     const kv = splitKeyValue(line.slice(indent));
-    if (!kv) { i++; continue; }
+    if (!kv) {
+      if (strictMode) throw new SyntaxError(`Not a "key: value" line: ${line.trim().slice(0, 60)}`);
+      i++;
+      continue;
+    }
     const block = kv.rest.match(BLOCK_SCALAR_RE);
     if (block) {
       const parsed = parseBlockScalar(lines, i + 1, indent, block[1], block[2]);
@@ -369,12 +386,21 @@ function parseList(lines, start, indent) {
 }
 
 /**
- * Parse a frontmatter block (the inner YAML, no fences) into an object.
+ * Parse a frontmatter block (the inner YAML, no fences) into an object. The
+ * default is lenient: unreadable lines are skipped. `{ strict: true }` throws a
+ * SyntaxError on lines that are not `key: value`, orphaned indentation, and
+ * malformed quoted or inline values, so callers can report unreadable files.
  */
-export function parseFrontmatter(fm) {
+export function parseFrontmatter(fm, { strict = false } = {}) {
   if (!fm) return {};
-  // Drop the newline before the closing fence so it is not read as a blank line.
-  return parseMap(fm.replace(/\n$/, '').split('\n'), 0, 0).value;
+  const previous = strictMode;
+  strictMode = strict;
+  try {
+    // Drop the newline before the closing fence so it is not read as a blank line.
+    return parseMap(fm.replace(/\n$/, '').split('\n'), 0, 0).value;
+  } finally {
+    strictMode = previous;
+  }
 }
 
 /** Parse a full document (with fences) into { data, body }. */