@oalo-ai/cli 0.1.0 → 0.2.0

package/src/migrate/toml.js

@@ -0,0 +1,242 @@
+/**
+ * A small TOML reader, enough for the config files `oalo migrate` reads
+ * (fly.toml, railway.toml): tables, arrays of tables, dotted and quoted keys,
+ * strings (basic, literal and multi-line), numbers, booleans, dates (kept as
+ * text), arrays (over several lines too) and inline tables.
+ *
+ * Throws an Error naming the line when it meets something it can't read.
+ */
+export function parseToml(text) {
+  const p = new Reader(String(text).replace(/^/, ""));
+  const root = {};
+  let table = root;
+
+  for (;;) {
+    p.skipBlank();
+    if (p.done()) break;
+
+    if (p.peek() === "[") {
+      const array = p.text.startsWith("[[", p.i);
+      p.i += array ? 2 : 1;
+      const path = p.keyPath();
+      p.expect(array ? "]]" : "]");
+      p.endOfLine();
+      table = array ? pushTable(root, path, p) : openTable(root, path, p);
+      continue;
+    }
+
+    const path = p.keyPath();
+    p.skipSpaces();
+    p.expect("=");
+    p.skipSpaces();
+    const value = p.value();
+    p.endOfLine();
+    assign(table, path, value, p);
+  }
+  return root;
+}
+
+class Reader {
+  constructor(text) {
+    this.text = text;
+    this.i = 0;
+  }
+  done() {
+    return this.i >= this.text.length;
+  }
+  peek() {
+    return this.text[this.i];
+  }
+  line() {
+    return this.text.slice(0, this.i).split("\n").length;
+  }
+  fail(msg) {
+    throw new Error(`line ${this.line()}: ${msg}`);
+  }
+  expect(s) {
+    if (!this.text.startsWith(s, this.i)) this.fail(`expected ${s}`);
+    this.i += s.length;
+  }
+  skipSpaces() {
+    while (this.peek() === " " || this.peek() === "\t") this.i++;
+  }
+  skipComment() {
+    if (this.peek() === "#") while (!this.done() && this.peek() !== "\n") this.i++;
+  }
+  /** Spaces, newlines and comments. */
+  skipBlank() {
+    for (;;) {
+      this.skipSpaces();
+      this.skipComment();
+      if (this.peek() === "\n" || this.peek() === "\r") this.i++;
+      else return;
+    }
+  }
+  endOfLine() {
+    this.skipSpaces();
+    this.skipComment();
+    if (this.done()) return;
+    if (this.peek() === "\r") this.i++;
+    if (this.peek() !== "\n") this.fail("expected the end of the line");
+    this.i++;
+  }
+
+  keyPath() {
+    const keys = [];
+    for (;;) {
+      this.skipSpaces();
+      keys.push(this.key());
+      this.skipSpaces();
+      if (this.peek() !== ".") return keys;
+      this.i++;
+    }
+  }
+  key() {
+    const c = this.peek();
+    if (c === '"') return this.basicString();
+    if (c === "'") return this.literalString();
+    const m = this.text.slice(this.i).match(/^[A-Za-z0-9_-]+/);
+    if (!m) this.fail("expected a key");
+    this.i += m[0].length;
+    return m[0];
+  }
+
+  value() {
+    const c = this.peek();
+    if (this.text.startsWith('"""', this.i)) return this.multiString('"""');
+    if (this.text.startsWith("'''", this.i)) return this.multiString("'''");
+    if (c === '"') return this.basicString();
+    if (c === "'") return this.literalString();
+    if (c === "[") return this.array();
+    if (c === "{") return this.inlineTable();
+    const m = this.text.slice(this.i).match(/^[^\s,\]}#]+/);
+    if (!m) this.fail("expected a value");
+    this.i += m[0].length;
+    return scalar(m[0], this);
+  }
+
+  basicString() {
+    this.i++;
+    let out = "";
+    while (!this.done()) {
+      const c = this.text[this.i++];
+      if (c === '"') return out;
+      if (c === "\n") this.fail("a string isn't closed on its line");
+      if (c === "\\") out += this.escape();
+      else out += c;
+    }
+    this.fail("a string isn't closed");
+  }
+  escape() {
+    const c = this.text[this.i++];
+    const simple = { n: "\n", t: "\t", r: "\r", '"': '"', "\\": "\\", b: "\b", f: "\f" };
+    if (c in simple) return simple[c];
+    if (c === "u" || c === "U") {
+      const len = c === "u" ? 4 : 8;
+      const hex = this.text.slice(this.i, this.i + len);
+      this.i += len;
+      return String.fromCodePoint(parseInt(hex, 16));
+    }
+    this.fail(`unknown escape \\${c}`);
+  }
+  literalString() {
+    const end = this.text.indexOf("'", this.i + 1);
+    const nl = this.text.indexOf("\n", this.i + 1);
+    if (end < 0 || (nl >= 0 && nl < end)) this.fail("a string isn't closed on its line");
+    const s = this.text.slice(this.i + 1, end);
+    this.i = end + 1;
+    return s;
+  }
+  multiString(q) {
+    this.i += 3;
+    if (this.peek() === "\r") this.i++;
+    if (this.peek() === "\n") this.i++;
+    const end = this.text.indexOf(q, this.i);
+    if (end < 0) this.fail(`${q} isn't closed`);
+    let s = this.text.slice(this.i, end);
+    this.i = end + 3;
+    if (q === '"""') {
+      s = s.replace(/\\\r?\n\s*/g, "").replace(/\\(.)/g, (_, ch) => ({ n: "\n", t: "\t", r: "\r", '"': '"', "\\": "\\" })[ch] ?? ch);
+    }
+    return s;
+  }
+  array() {
+    this.i++;
+    const out = [];
+    for (;;) {
+      this.skipBlank();
+      if (this.peek() === "]") {
+        this.i++;
+        return out;
+      }
+      out.push(this.value());
+      this.skipBlank();
+      if (this.peek() === ",") this.i++;
+      else if (this.peek() !== "]") this.fail("expected , or ] in an array");
+    }
+  }
+  inlineTable() {
+    this.i++;
+    const out = {};
+    this.skipSpaces();
+    if (this.peek() === "}") {
+      this.i++;
+      return out;
+    }
+    for (;;) {
+      const path = this.keyPath();
+      this.skipSpaces();
+      this.expect("=");
+      this.skipSpaces();
+      assign(out, path, this.value(), this);
+      this.skipSpaces();
+      if (this.peek() === ",") {
+        this.i++;
+        this.skipSpaces();
+      } else if (this.peek() === "}") {
+        this.i++;
+        return out;
+      } else this.fail("expected , or } in an inline table");
+    }
+  }
+}
+
+function scalar(word, p) {
+  if (word === "true") return true;
+  if (word === "false") return false;
+  if (/^[+-]?(\d[\d_]*)(\.\d[\d_]*)?([eE][+-]?\d+)?$/.test(word)) return Number(word.replace(/_/g, ""));
+  if (/^0x[0-9a-fA-F_]+$/.test(word)) return parseInt(word.slice(2).replace(/_/g, ""), 16);
+  // Dates and times are kept as text: nothing here needs them as dates.
+  if (/^\d{4}-\d{2}-\d{2}/.test(word) || /^\d{2}:\d{2}/.test(word)) return word;
+  if (/^[+-]?(inf|nan)$/.test(word)) return Number(word.replace("inf", "Infinity").replace("nan", "NaN"));
+  p.fail(`can't read the value ${word}`);
+}
+
+function walk(root, path, p) {
+  let t = root;
+  for (const k of path) {
+    if (t[k] === undefined) t[k] = {};
+    t = Array.isArray(t[k]) ? t[k][t[k].length - 1] : t[k];
+    if (typeof t !== "object" || t === null) p.fail(`${path.join(".")} is already a value`);
+  }
+  return t;
+}
+
+function openTable(root, path, p) {
+  return walk(root, path, p);
+}
+
+function pushTable(root, path, p) {
+  const parent = walk(root, path.slice(0, -1), p);
+  const k = path[path.length - 1];
+  if (parent[k] === undefined) parent[k] = [];
+  if (!Array.isArray(parent[k])) p.fail(`${path.join(".")} is already a table`);
+  const t = {};
+  parent[k].push(t);
+  return t;
+}
+
+function assign(table, path, value, p) {
+  const t = walk(table, path.slice(0, -1), p);
+  t[path[path.length - 1]] = value;
+}

package/src/migrate/yaml.js

@@ -0,0 +1,179 @@
+/**
+ * A small YAML reader, enough for render.yaml: block mappings and sequences by
+ * indentation, a sequence item that starts a mapping (`- type: web`), plain,
+ * single- and double-quoted scalars, block scalars (`|`, `>`), simple flow
+ * sequences (`[a, b]`) and comments.
+ *
+ * Anchors, aliases, tags and several documents in one file aren't supported:
+ * it throws an Error naming the line, so the caller can say to copy the
+ * commands by hand instead.
+ */
+export function parseYaml(text) {
+  const lines = String(text).replace(/^/, "").split(/\r?\n/);
+  const r = new Reader(lines);
+  r.skip();
+  if (r.atEnd()) return null;
+  const value = r.block(r.indent());
+  r.skip();
+  if (!r.atEnd()) r.fail("unexpected indentation");
+  return value;
+}
+
+class Reader {
+  constructor(lines) {
+    this.lines = lines;
+    this.i = 0;
+  }
+  fail(msg) {
+    throw new Error(`line ${this.i + 1}: ${msg}`);
+  }
+  atEnd() {
+    return this.i >= this.lines.length;
+  }
+  /** Past blank lines, comments and a leading document marker. */
+  skip() {
+    while (!this.atEnd()) {
+      const t = this.lines[this.i].trim();
+      if (t === "" || t.startsWith("#") || (t === "---" && this.i === 0)) this.i++;
+      else if (t === "---" || t === "...") this.fail("several YAML documents in one file aren't supported");
+      else return;
+    }
+  }
+  indent() {
+    return this.lines[this.i].match(/^ */)[0].length;
+  }
+  content() {
+    return this.lines[this.i].slice(this.indent());
+  }
+
+  block(indent) {
+    const c = this.content();
+    return c === "-" || c.startsWith("- ") ? this.sequence(indent) : this.mapping(indent);
+  }
+
+  mapping(indent) {
+    const out = {};
+    for (;;) {
+      this.skip();
+      if (this.atEnd() || this.indent() < indent) return out;
+      if (this.indent() > indent) this.fail("unexpected indentation");
+      const c = this.content();
+      if (c === "-" || c.startsWith("- ")) return out;
+
+      const m = c.match(/^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[^\s"'#][^:#]*?)\s*:(?:\s+|$)(.*)$/);
+      if (!m) this.fail("expected key: value");
+      const key = unquote(m[1].trim(), this);
+      const rest = stripComment(m[2]);
+      this.i++;
+      out[key] = this.valueAfterKey(rest, indent);
+    }
+  }
+
+  valueAfterKey(rest, indent) {
+    if (/^[|>][-+]?$/.test(rest)) return this.blockScalar(rest, indent);
+    if (rest !== "") return scalar(rest, this);
+    this.skip();
+    if (this.atEnd()) return null;
+    const next = this.indent();
+    const c = this.content();
+    if (next > indent) return this.block(next);
+    // `key:` followed by `- item` at the same indentation is a sequence.
+    if (next === indent && (c === "-" || c.startsWith("- "))) return this.sequence(indent);
+    return null;
+  }
+
+  sequence(indent) {
+    const out = [];
+    for (;;) {
+      this.skip();
+      if (this.atEnd() || this.indent() !== indent) return out;
+      const c = this.content();
+      if (!(c === "-" || c.startsWith("- "))) return out;
+
+      const after = c.slice(1);
+      const pad = after.match(/^ */)[0].length;
+      const item = after.slice(pad);
+      if (item === "" || item.startsWith("#")) {
+        this.i++;
+        this.skip();
+        out.push(!this.atEnd() && this.indent() > indent ? this.block(this.indent()) : null);
+      } else if (/^("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[^\s"'#\[{][^:#]*?)\s*:(\s|$)/.test(item)) {
+        // `- key: value` starts a mapping whose keys sit at the item's column.
+        const col = indent + 1 + pad;
+        this.lines[this.i] = " ".repeat(col) + item;
+        out.push(this.mapping(col));
+      } else {
+        this.i++;
+        out.push(scalar(stripComment(item), this));
+      }
+    }
+  }
+
+  blockScalar(head, indent) {
+    const fold = head[0] === ">";
+    const chomp = head[1];
+    const body = [];
+    let col = null;
+    while (!this.atEnd()) {
+      const line = this.lines[this.i];
+      if (line.trim() === "") {
+        body.push("");
+        this.i++;
+        continue;
+      }
+      const ind = line.match(/^ */)[0].length;
+      if (ind <= indent) break;
+      if (col === null) col = ind;
+      if (ind < col) break;
+      body.push(line.slice(col));
+      this.i++;
+    }
+    while (body.length && body[body.length - 1] === "" && chomp !== "+") body.pop();
+    let s = fold ? body.join("\n").replace(/([^\n])\n(?=[^\n])/g, "$1 ") : body.join("\n");
+    if (chomp !== "-" && s !== "") s += "\n";
+    return s;
+  }
+}
+
+function stripComment(s) {
+  if (s.startsWith('"') || s.startsWith("'")) return s.trim();
+  return s.replace(/\s+#.*$/, "").trim();
+}
+
+function unquote(s, r) {
+  if (s.startsWith('"')) {
+    try {
+      return JSON.parse(s);
+    } catch {
+      r.fail(`can't read the string ${s}`);
+    }
+  }
+  if (s.startsWith("'")) return s.slice(1, -1).replace(/''/g, "'");
+  return s;
+}
+
+function scalar(s, r) {
+  if (s.startsWith("&") || s.startsWith("*") || s.startsWith("!")) r.fail("anchors, aliases and tags aren't supported");
+  if (s.startsWith('"')) {
+    if (!/"$/.test(s) || s.length < 2) r.fail("a string isn't closed on its line");
+    return unquote(s, r);
+  }
+  if (s.startsWith("'")) {
+    if (!/'$/.test(s) || s.length < 2) r.fail("a string isn't closed on its line");
+    return unquote(s, r);
+  }
+  if (s.startsWith("[")) {
+    if (!s.endsWith("]")) r.fail("a [ list isn't closed on its line");
+    const inner = s.slice(1, -1).trim();
+    return inner === "" ? [] : inner.split(",").map((x) => scalar(x.trim(), r));
+  }
+  if (s.startsWith("{")) {
+    if (s === "{}") return {};
+    r.fail("{ } maps on one line aren't supported");
+  }
+  if (s === "~" || s === "null" || s === "Null" || s === "NULL") return null;
+  if (/^(true|True|TRUE)$/.test(s)) return true;
+  if (/^(false|False|FALSE)$/.test(s)) return false;
+  if (/^[+-]?\d+(\.\d+)?$/.test(s)) return Number(s);
+  return s;
+}

package/src/server.js

@@ -66,7 +66,7 @@ export async function requireFeature(url, feature, what) {
   if (old) throw new Error(old);
   if (!info.features.includes(feature)) {
     throw new Error(
-      `${url} runs an older OALO than this CLI, so \`${what}\` isn't available there yet. It will be once the workspace is updated.`,
+      `${url} runs an older Oalo than this CLI, so \`${what}\` isn't available there yet. It will be once the workspace is updated.`,
     );
   }
   return info;