@zeyue0329/xiaoma-cli 1.13.0 → 1.15.1

package/src/scripts/resolve_config.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Resolve XiaoMa's central config using four-layer TOML merge.
+ *
+ * Node port of the original Python resolver (no Python runtime dependency).
+ * Uses the vendored ./toml.js parser; zero npm dependencies at runtime.
+ *
+ * Layers (highest priority last):
+ *   1. {project-root}/_xiaoma/config.toml              (installer-owned team, required)
+ *   2. {project-root}/_xiaoma/config.user.toml         (installer-owned user)
+ *   3. {project-root}/_xiaoma/custom/config.toml       (human-authored team, committed)
+ *   4. {project-root}/_xiaoma/custom/config.user.toml  (human-authored user, gitignored)
+ *
+ * Usage:
+ *   node resolve_config.js --project-root /abs/path/to/project
+ *   node resolve_config.js --project-root ... --key core
+ *   node resolve_config.js --project-root ... --key agents
+ *
+ * Merge rules are identical to resolve_customization.js (structural; arrays of
+ * tables keyed by code/id replace-and-append, other arrays append, tables deep
+ * merge, scalars override).
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const toml = require('./toml.js');
+
+const KEYED_MERGE_FIELDS = ['code', 'id'];
+const MISSING = Symbol('missing');
+
+function loadToml(filePath, required = false) {
+  if (!fs.existsSync(filePath)) {
+    if (required) {
+      process.stderr.write(`error: required config file not found: ${filePath}\n`);
+      process.exit(1);
+    }
+    return {};
+  }
+  try {
+    const parsed = toml.parse(fs.readFileSync(filePath, 'utf8'));
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch (error) {
+    const level = required ? 'error' : 'warning';
+    process.stderr.write(`${level}: failed to parse ${filePath}: ${error.message}\n`);
+    if (required) process.exit(1);
+    return {};
+  }
+}
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function detectKeyedMergeField(items) {
+  if (items.length === 0 || !items.every(isPlainObject)) return null;
+  for (const candidate of KEYED_MERGE_FIELDS) {
+    if (items.every((item) => item[candidate] !== undefined && item[candidate] !== null)) return candidate;
+  }
+  return null;
+}
+
+function mergeByKey(base, override, keyName) {
+  const result = [];
+  const indexByKey = new Map();
+  for (const item of base) {
+    if (!isPlainObject(item)) continue;
+    if (item[keyName] !== undefined && item[keyName] !== null) indexByKey.set(item[keyName], result.length);
+    result.push({ ...item });
+  }
+  for (const item of override) {
+    if (!isPlainObject(item)) {
+      result.push(item);
+      continue;
+    }
+    const key = item[keyName];
+    if (key !== undefined && key !== null && indexByKey.has(key)) {
+      result[indexByKey.get(key)] = { ...item };
+    } else {
+      if (key !== undefined && key !== null) indexByKey.set(key, result.length);
+      result.push({ ...item });
+    }
+  }
+  return result;
+}
+
+function mergeArrays(base, override) {
+  const baseArr = Array.isArray(base) ? base : [];
+  const overrideArr = Array.isArray(override) ? override : [];
+  const keyedField = detectKeyedMergeField([...baseArr, ...overrideArr]);
+  if (keyedField) return mergeByKey(baseArr, overrideArr, keyedField);
+  return [...baseArr, ...overrideArr];
+}
+
+function deepMerge(base, override) {
+  if (isPlainObject(base) && isPlainObject(override)) {
+    const result = { ...base };
+    for (const [key, overVal] of Object.entries(override)) {
+      result[key] = key in result ? deepMerge(result[key], overVal) : overVal;
+    }
+    return result;
+  }
+  if (Array.isArray(base) && Array.isArray(override)) return mergeArrays(base, override);
+  return override;
+}
+
+function extractKey(data, dottedKey) {
+  let current = data;
+  for (const part of dottedKey.split('.')) {
+    if (isPlainObject(current) && part in current) current = current[part];
+    else return MISSING;
+  }
+  return current;
+}
+
+function parseArgs(argv) {
+  const out = { projectRoot: null, key: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--project-root' || a === '-p') out.projectRoot = argv[++i];
+    else if (a === '--key' || a === '-k') out.key.push(argv[++i]);
+    else if (a === '--help' || a === '-h') {
+      process.stdout.write('usage: node resolve_config.js --project-root <dir> [--key <dotted>]...\n');
+      process.exit(0);
+    }
+  }
+  if (!out.projectRoot) {
+    process.stderr.write('error: --project-root is required\n');
+    process.exit(2);
+  }
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const projectRoot = path.resolve(args.projectRoot);
+  const xiaomaDir = path.join(projectRoot, '_xiaoma');
+
+  const baseTeam = loadToml(path.join(xiaomaDir, 'config.toml'), true);
+  const baseUser = loadToml(path.join(xiaomaDir, 'config.user.toml'));
+  const customTeam = loadToml(path.join(xiaomaDir, 'custom', 'config.toml'));
+  const customUser = loadToml(path.join(xiaomaDir, 'custom', 'config.user.toml'));
+
+  let merged = deepMerge(baseTeam, baseUser);
+  merged = deepMerge(merged, customTeam);
+  merged = deepMerge(merged, customUser);
+
+  let output;
+  if (args.key.length > 0) {
+    output = {};
+    for (const key of args.key) {
+      const value = extractKey(merged, key);
+      if (value !== MISSING) output[key] = value;
+    }
+  } else {
+    output = merged;
+  }
+  process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+}
+
+main();

package/src/scripts/resolve_customization.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * Resolve customization for a XiaoMa skill using three-layer TOML merge.
+ *
+ * Node port of the original Python resolver (no Python runtime dependency).
+ * Uses the vendored ./toml.js parser, so it runs on an end-user machine with
+ * zero npm dependencies.
+ *
+ * Layers (highest priority last):
+ *   1. {skill-root}/customize.toml                     (skill defaults, required)
+ *   2. {project-root}/_xiaoma/custom/{name}.toml        (team/org, committed)
+ *   3. {project-root}/_xiaoma/custom/{name}.user.toml   (personal, gitignored)
+ *
+ * Usage:
+ *   node resolve_customization.js --skill /abs/path/to/skill-dir
+ *   node resolve_customization.js --skill ... --key agent
+ *   node resolve_customization.js --skill ... --key agent.menu --key agent.name
+ *
+ * Merge rules (purely structural — no field-name special-casing):
+ *   - Scalars: override wins
+ *   - Tables: deep merge
+ *   - Arrays of tables where EVERY item shares the same identifier (all `code`,
+ *     or all `id`): merge by that key (matching keys replace, new keys append)
+ *   - All other arrays: append (base items then override items)
+ * No removal mechanism. If the merge cannot run, the skill's SKILL.md carries an
+ * LLM fallback that performs the same merge manually.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const toml = require('./toml.js');
+
+const KEYED_MERGE_FIELDS = ['code', 'id'];
+const MISSING = Symbol('missing');
+
+function findProjectRoot(start) {
+  let current = path.resolve(start);
+  for (;;) {
+    if (fs.existsSync(path.join(current, '_xiaoma')) || fs.existsSync(path.join(current, '.git'))) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function loadToml(filePath, required = false) {
+  if (!fs.existsSync(filePath)) {
+    if (required) {
+      process.stderr.write(`error: required customization file not found: ${filePath}\n`);
+      process.exit(1);
+    }
+    return {};
+  }
+  try {
+    const parsed = toml.parse(fs.readFileSync(filePath, 'utf8'));
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      if (required) {
+        process.stderr.write(`error: ${filePath} did not parse to a table\n`);
+        process.exit(1);
+      }
+      return {};
+    }
+    return parsed;
+  } catch (error) {
+    const level = required ? 'error' : 'warning';
+    process.stderr.write(`${level}: failed to parse ${filePath}: ${error.message}\n`);
+    if (required) process.exit(1);
+    return {};
+  }
+}
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function detectKeyedMergeField(items) {
+  if (items.length === 0 || !items.every(isPlainObject)) return null;
+  for (const candidate of KEYED_MERGE_FIELDS) {
+    if (items.every((item) => item[candidate] !== undefined && item[candidate] !== null)) return candidate;
+  }
+  return null;
+}
+
+function mergeByKey(base, override, keyName) {
+  const result = [];
+  const indexByKey = new Map();
+  for (const item of base) {
+    if (!isPlainObject(item)) continue;
+    if (item[keyName] !== undefined && item[keyName] !== null) indexByKey.set(item[keyName], result.length);
+    result.push({ ...item });
+  }
+  for (const item of override) {
+    if (!isPlainObject(item)) {
+      result.push(item);
+      continue;
+    }
+    const key = item[keyName];
+    if (key !== undefined && key !== null && indexByKey.has(key)) {
+      result[indexByKey.get(key)] = { ...item };
+    } else {
+      if (key !== undefined && key !== null) indexByKey.set(key, result.length);
+      result.push({ ...item });
+    }
+  }
+  return result;
+}
+
+function mergeArrays(base, override) {
+  const baseArr = Array.isArray(base) ? base : [];
+  const overrideArr = Array.isArray(override) ? override : [];
+  const keyedField = detectKeyedMergeField([...baseArr, ...overrideArr]);
+  if (keyedField) return mergeByKey(baseArr, overrideArr, keyedField);
+  return [...baseArr, ...overrideArr];
+}
+
+function deepMerge(base, override) {
+  if (isPlainObject(base) && isPlainObject(override)) {
+    const result = { ...base };
+    for (const [key, overVal] of Object.entries(override)) {
+      result[key] = key in result ? deepMerge(result[key], overVal) : overVal;
+    }
+    return result;
+  }
+  if (Array.isArray(base) && Array.isArray(override)) return mergeArrays(base, override);
+  return override;
+}
+
+function extractKey(data, dottedKey) {
+  let current = data;
+  for (const part of dottedKey.split('.')) {
+    if (isPlainObject(current) && part in current) current = current[part];
+    else return MISSING;
+  }
+  return current;
+}
+
+function parseArgs(argv) {
+  const out = { skill: null, key: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--skill' || a === '-s') out.skill = argv[++i];
+    else if (a === '--key' || a === '-k') out.key.push(argv[++i]);
+    else if (a === '--help' || a === '-h') {
+      process.stdout.write('usage: node resolve_customization.js --skill <dir> [--key <dotted>]...\n');
+      process.exit(0);
+    }
+  }
+  if (!out.skill) {
+    process.stderr.write('error: --skill is required\n');
+    process.exit(2);
+  }
+  return out;
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const skillDir = path.resolve(args.skill);
+  const skillName = path.basename(skillDir);
+  const defaults = loadToml(path.join(skillDir, 'customize.toml'), true);
+
+  const projectRoot = findProjectRoot(skillDir) || findProjectRoot(process.cwd());
+  let team = {};
+  let user = {};
+  if (projectRoot) {
+    const customDir = path.join(projectRoot, '_xiaoma', 'custom');
+    team = loadToml(path.join(customDir, `${skillName}.toml`));
+    user = loadToml(path.join(customDir, `${skillName}.user.toml`));
+  }
+
+  let merged = deepMerge(defaults, team);
+  merged = deepMerge(merged, user);
+
+  let output;
+  if (args.key.length > 0) {
+    output = {};
+    for (const key of args.key) {
+      const value = extractKey(merged, key);
+      if (value !== MISSING) output[key] = value;
+    }
+  } else {
+    output = merged;
+  }
+  process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+}
+
+main();

package/src/scripts/toml.js

@@ -0,0 +1,338 @@
+/**
+ * toml.js — self-contained TOML parser (no dependencies).
+ *
+ * Vendored into the installed `_xiaoma/scripts/` so the Node customization
+ * resolvers run on an end-user machine with zero npm dependencies (the parity
+ * for what Python's stdlib `tomllib` gave the original resolvers).
+ *
+ * Supports the TOML subset used by XiaoMa customize.toml / config.toml and the
+ * common cases a user override might add:
+ *   - comments (# to end of line, ignored inside strings)
+ *   - table headers [a.b.c] and arrays-of-tables [[a.b]]
+ *   - bare / dotted keys = value
+ *   - basic strings "..." (with \n \t \" \\ \uXXXX escapes), literal strings '...'
+ *   - multi-line basic """...""" and literal '''...''' strings
+ *   - integers, floats, booleans (true/false)
+ *   - arrays [ ... ] including multi-line and nested, mixed scalar/string
+ *   - inline tables { k = v, ... }
+ *   - dotted-key value assignment (a.b = c -> {a:{b:c}})
+ * Not supported (errors cleanly): datetimes. These do not appear in XiaoMa skill
+ * TOML; the SKILL.md activation carries an LLM merge fallback.
+ *
+ * parse(text) -> plain object.
+ */
+
+'use strict';
+
+function fail(msg, lineNo) {
+  throw new Error(`TOML parse error${lineNo != null ? ` (line ${lineNo})` : ''}: ${msg}`);
+}
+
+// --- value scanning over a single logical string (arrays/inline-tables joined) ---
+function parseValue(str, ctx) {
+  const s = str.trim();
+  if (s.length === 0) fail('empty value', ctx.line);
+  const c = s[0];
+  if (c === '"' || c === "'") return parseString(s, ctx);
+  if (c === '[') return parseArray(s, ctx);
+  if (c === '{') return parseInlineTable(s, ctx);
+  // scalar literal (bool / int / float)
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  if (/^[+-]?\d[\d_]*$/.test(s)) return Number.parseInt(s.replace(/_/g, ''), 10);
+  if (/^[+-]?(\d[\d_]*)?\.\d[\d_]*([eE][+-]?\d+)?$/.test(s) || /^[+-]?\d[\d_]*[eE][+-]?\d+$/.test(s)) {
+    return Number.parseFloat(s.replace(/_/g, ''));
+  }
+  fail(`unrecognized value: ${s}`, ctx.line);
+}
+
+function parseString(s, ctx) {
+  // multi-line
+  if (s.startsWith('"""')) {
+    const end = s.indexOf('"""', 3);
+    if (end === -1) fail('unterminated multi-line basic string', ctx.line);
+    let body = s.slice(3, end);
+    if (body.startsWith('\n')) body = body.slice(1);
+    return unescapeBasic(body);
+  }
+  if (s.startsWith("'''")) {
+    const end = s.indexOf("'''", 3);
+    if (end === -1) fail('unterminated multi-line literal string', ctx.line);
+    let body = s.slice(3, end);
+    if (body.startsWith('\n')) body = body.slice(1);
+    return body;
+  }
+  if (s[0] === '"') {
+    const { value, rest } = scanBasic(s, ctx);
+    if (rest.trim() !== '') fail(`trailing content after string: ${rest}`, ctx.line);
+    return value;
+  }
+  // literal '...'
+  const end = s.indexOf("'", 1);
+  if (end === -1) fail('unterminated literal string', ctx.line);
+  if (s.slice(end + 1).trim() !== '') fail(`trailing content after literal string`, ctx.line);
+  return s.slice(1, end);
+}
+
+function scanBasic(s, ctx) {
+  // s[0] === '"'; returns {value, rest} consuming the quoted string
+  let i = 1;
+  let out = '';
+  while (i < s.length) {
+    const ch = s[i];
+    if (ch === '\\') {
+      const n = s[i + 1];
+      const map = { n: '\n', t: '\t', r: '\r', '"': '"', '\\': '\\', b: '\b', f: '\f' };
+      if (n in map) {
+        out += map[n];
+        i += 2;
+        continue;
+      }
+      if (n === 'u' || n === 'U') {
+        const len = n === 'u' ? 4 : 8;
+        const hex = s.slice(i + 2, i + 2 + len);
+        out += String.fromCodePoint(Number.parseInt(hex, 16));
+        i += 2 + len;
+        continue;
+      }
+      fail(`invalid escape \\${n}`, ctx.line);
+    }
+    if (ch === '"') return { value: out, rest: s.slice(i + 1) };
+    out += ch;
+    i += 1;
+  }
+  fail('unterminated basic string', ctx.line);
+}
+
+function unescapeBasic(body) {
+  return body.replace(/\\(u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|[ntr"\\bf])/g, (_, e) => {
+    const map = { n: '\n', t: '\t', r: '\r', '"': '"', '\\': '\\', b: '\b', f: '\f' };
+    if (e[0] === 'u' || e[0] === 'U') return String.fromCodePoint(Number.parseInt(e.slice(1), 16));
+    return map[e];
+  });
+}
+
+// Split top-level array/inline-table elements respecting nested brackets/strings.
+function splitElements(inner, ctx) {
+  const parts = [];
+  let depth = 0;
+  let buf = '';
+  let i = 0;
+  while (i < inner.length) {
+    const ch = inner[i];
+    if (ch === '"' || ch === "'") {
+      // consume string token verbatim into buf
+      const quote = ch;
+      buf += ch;
+      i += 1;
+      while (i < inner.length) {
+        buf += inner[i];
+        if (inner[i] === '\\' && quote === '"') {
+          buf += inner[i + 1] ?? '';
+          i += 2;
+          continue;
+        }
+        if (inner[i] === quote) {
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === '[' || ch === '{') depth += 1;
+    if (ch === ']' || ch === '}') depth -= 1;
+    if (ch === ',' && depth === 0) {
+      parts.push(buf);
+      buf = '';
+      i += 1;
+      continue;
+    }
+    buf += ch;
+    i += 1;
+  }
+  if (buf.trim() !== '') parts.push(buf);
+  return parts;
+}
+
+function parseArray(s, ctx) {
+  if (s[s.length - 1] !== ']') fail('array not closed on logical line', ctx.line);
+  const inner = s.slice(1, -1);
+  return splitElements(inner, ctx)
+    .map((e) => e.trim())
+    .filter((e) => e !== '')
+    .map((e) => parseValue(e, ctx));
+}
+
+function parseInlineTable(s, ctx) {
+  if (s[s.length - 1] !== '}') fail('inline table not closed', ctx.line);
+  const inner = s.slice(1, -1);
+  const obj = {};
+  for (const pair of splitElements(inner, ctx)) {
+    const t = pair.trim();
+    if (t === '') continue;
+    const eq = findKeyEq(t);
+    if (eq === -1) fail(`invalid inline-table pair: ${t}`, ctx.line);
+    obj[stripKey(t.slice(0, eq))] = parseValue(t.slice(eq + 1), ctx);
+  }
+  return obj;
+}
+
+function stripKey(k) {
+  const t = k.trim();
+  if ((t[0] === '"' && t[t.length - 1] === '"') || (t[0] === "'" && t[t.length - 1] === "'")) return t.slice(1, -1);
+  return t;
+}
+
+// find the `=` that separates key from value (skip those inside quotes)
+function findKeyEq(line) {
+  let inq = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inq) {
+      if (ch === inq) inq = null;
+    } else if (ch === '"' || ch === "'") inq = ch;
+    else if (ch === '=') return i;
+  }
+  return -1;
+}
+
+// strip a trailing unquoted comment from a logical line
+function stripComment(line) {
+  let inq = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inq) {
+      if (ch === '\\' && inq === '"') {
+        i += 1;
+        continue;
+      }
+      if (ch === inq) inq = null;
+    } else if (ch === '"' || ch === "'") inq = ch;
+    else if (ch === '#') return line.slice(0, i);
+  }
+  return line;
+}
+
+function setPath(root, pathParts, value) {
+  let cur = root;
+  for (let i = 0; i < pathParts.length - 1; i++) {
+    const p = pathParts[i];
+    if (cur[p] === undefined) cur[p] = {};
+    else if (Array.isArray(cur[p])) cur[p] = cur[p][cur[p].length - 1];
+    cur = cur[p];
+  }
+  cur[pathParts[pathParts.length - 1]] = value;
+}
+
+function getTable(root, pathParts) {
+  let cur = root;
+  for (const p of pathParts) {
+    if (cur[p] === undefined) cur[p] = {};
+    else if (Array.isArray(cur[p])) cur[p] = cur[p][cur[p].length - 1];
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function parse(text) {
+  const root = {};
+  const rawLines = text.split(/\r?\n/);
+  let current = root; // current table for key=value
+  let lineNo = 0;
+
+  for (let li = 0; li < rawLines.length; li++) {
+    lineNo = li + 1;
+    let line = stripComment(rawLines[li]).trim();
+    if (line === '') continue;
+
+    // array-of-tables [[a.b]]
+    if (line.startsWith('[[')) {
+      if (!line.endsWith(']]')) fail('malformed array-of-tables header', lineNo);
+      const parts = line.slice(2, -2).trim().split('.').map(stripKey);
+      const parent = getTable(root, parts.slice(0, -1));
+      const last = parts[parts.length - 1];
+      if (!Array.isArray(parent[last])) parent[last] = [];
+      const tbl = {};
+      parent[last].push(tbl);
+      current = tbl;
+      continue;
+    }
+    // table header [a.b]
+    if (line.startsWith('[')) {
+      if (!line.endsWith(']')) fail('malformed table header', lineNo);
+      const parts = line.slice(1, -1).trim().split('.').map(stripKey);
+      current = getTable(root, parts);
+      continue;
+    }
+
+    // key = value  (value may span multiple physical lines for arrays/inline tables)
+    const eq = findKeyEq(line);
+    if (eq === -1) fail(`expected key = value: ${line}`, lineNo);
+    const keyParts = splitDottedKey(line.slice(0, eq));
+    let valStr = line.slice(eq + 1).trim();
+
+    // accumulate multi-line array / inline table until brackets balance
+    const opener = valStr[0];
+    if (opener === '[' || opener === '{') {
+      while (!bracketsBalanced(valStr)) {
+        li += 1;
+        if (li >= rawLines.length) fail('unterminated multi-line value', lineNo);
+        valStr += '\n' + stripComment(rawLines[li]).trim();
+      }
+    } else if (valStr.startsWith('"""') || valStr.startsWith("'''")) {
+      const delim = valStr.slice(0, 3);
+      while (valStr.indexOf(delim, 3) === -1) {
+        li += 1;
+        if (li >= rawLines.length) fail('unterminated multi-line string', lineNo);
+        valStr += '\n' + rawLines[li];
+      }
+    }
+    const ctx = { line: lineNo };
+    setPath(current, keyParts, parseValue(valStr, ctx));
+  }
+  return root;
+}
+
+// Split a (possibly dotted) bare/quoted key into path segments, honoring quotes.
+function splitDottedKey(raw) {
+  const parts = [];
+  let buf = '';
+  let inq = null;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (inq) {
+      if (ch === inq) inq = null;
+      else buf += ch;
+    } else if (ch === '"' || ch === "'") inq = ch;
+    else if (ch === '.') {
+      parts.push(buf.trim());
+      buf = '';
+    } else buf += ch;
+  }
+  parts.push(buf.trim());
+  return parts.map((p) => stripKey(p));
+}
+
+function bracketsBalanced(s) {
+  let depth = 0;
+  let inq = null;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (inq) {
+      if (ch === '\\' && inq === '"') {
+        i += 1;
+        continue;
+      }
+      if (ch === inq) inq = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") inq = ch;
+    else if (ch === '[' || ch === '{') depth += 1;
+    else if (ch === ']' || ch === '}') depth -= 1;
+    else if (ch === '#') break; // rest is comment
+  }
+  return depth <= 0;
+}
+
+module.exports = { parse };