@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/cmd_settings_check.js

@@ -0,0 +1,574 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_settings_check.ts
+import process from "node:process";
+import * as fs from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as path from "node:path";
+
+// src/scripts/sync_yaml_rt.ts
+function makeNode(partial = {}) {
+  return {
+    key: null,
+    indent: 0,
+    raw_value: null,
+    inline_comment: null,
+    is_list_item: false,
+    leading: [],
+    header_line: null,
+    trailing: [],
+    children: [],
+    origin_line: null,
+    line_ending: "\n",
+    ...partial
+  };
+}
+function splitKeepEnds(text) {
+  const out = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "\n") {
+      out.push(text.slice(start, i + 1));
+      start = i + 1;
+    } else if (ch === "\r") {
+      if (text[i + 1] === "\n") {
+        out.push(text.slice(start, i + 2));
+        start = i + 2;
+        i++;
+      } else {
+        out.push(text.slice(start, i + 1));
+        start = i + 1;
+      }
+    }
+  }
+  if (start < text.length) {
+    out.push(text.slice(start));
+  }
+  return out;
+}
+function tokenise(text) {
+  const out = [];
+  if (text === "") {
+    return out;
+  }
+  const rawLines = splitKeepEnds(text);
+  for (let idx = 0; idx < rawLines.length; idx++) {
+    const i = idx + 1;
+    const raw = rawLines[idx];
+    if (raw === void 0) {
+      continue;
+    }
+    let le;
+    let body;
+    if (raw.endsWith("\r\n")) {
+      le = "\r\n";
+      body = raw.slice(0, -2);
+    } else if (raw.endsWith("\n")) {
+      le = "\n";
+      body = raw.slice(0, -1);
+    } else if (raw.endsWith("\r")) {
+      le = "\r";
+      body = raw.slice(0, -1);
+    } else {
+      le = "";
+      body = raw;
+    }
+    const stripped0 = body.replace(/^[ \t]+/, "");
+    const ws = body.slice(0, body.length - stripped0.length);
+    if (ws.includes("	")) {
+      throw new Error(`tab character in indent at line ${i} (only spaces allowed)`);
+    }
+    const indent = ws.length;
+    const stripped = body.trim();
+    let kind;
+    if (stripped === "") {
+      kind = "blank";
+    } else if (stripped.startsWith("#")) {
+      kind = "comment";
+    } else if (stripped.startsWith("- ") || stripped === "-") {
+      kind = "list";
+    } else {
+      kind = "mapping";
+    }
+    out.push({ number: i, raw, line_ending: le, body, indent, kind });
+  }
+  return out;
+}
+function rstripSpacesTabs(s) {
+  return s.replace(/[ \t]+$/, "");
+}
+function splitInlineComment(valuePart) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < valuePart.length; i++) {
+    const ch = valuePart[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+    } else if (ch === "#" && !inSingle && !inDouble) {
+      if (i === 0 || valuePart[i - 1] === " " || valuePart[i - 1] === "	") {
+        const valueText = rstripSpacesTabs(valuePart.slice(0, i));
+        const commentText = valuePart.slice(i);
+        return [valueText, commentText];
+      }
+    }
+  }
+  return [rstripSpacesTabs(valuePart) || "", null];
+}
+function parseMappingLine(body) {
+  const stripped = body.replace(/^ +/, "");
+  let rawKey;
+  let rest;
+  let key;
+  if (stripped.startsWith('"')) {
+    const end = stripped.indexOf('"', 1);
+    if (end === -1) {
+      throw new Error("unterminated double-quoted key");
+    }
+    rawKey = stripped.slice(0, end + 1);
+    rest = stripped.slice(end + 1);
+    key = stripped.slice(1, end);
+  } else if (stripped.startsWith("'")) {
+    const end = stripped.indexOf("'", 1);
+    if (end === -1) {
+      throw new Error("unterminated single-quoted key");
+    }
+    rawKey = stripped.slice(0, end + 1);
+    rest = stripped.slice(end + 1);
+    key = stripped.slice(1, end);
+  } else {
+    let colon = -1;
+    for (let i = 0; i < stripped.length; i++) {
+      if (stripped[i] === ":") {
+        const following = stripped.slice(i + 1, i + 2);
+        if (following === "" || following === " " || following === "	" || following === "#") {
+          colon = i;
+          break;
+        }
+      }
+    }
+    if (colon === -1) {
+      throw new Error(`missing ':' in mapping line: ${pyRepr(stripped)}`);
+    }
+    rawKey = stripped.slice(0, colon);
+    rest = stripped.slice(colon);
+    key = rawKey;
+  }
+  if (rest.startsWith(":")) {
+    rest = rest.slice(1);
+  } else if (rest.startsWith(" :") || rest.startsWith("	:")) {
+    rest = rest.replace(/^[ \t]+/, "").slice(1);
+  } else if (rest.replace(/^\s+/, "").startsWith(":")) {
+    rest = rest.replace(/^\s+/, "").slice(1);
+  } else {
+    throw new Error(`missing ':' after key ${pyRepr(rawKey)}: rest=${pyRepr(rest)}`);
+  }
+  const restText = rest.replace(/^[ \t]+/, "");
+  if (restText === "") {
+    return [key, null, null];
+  }
+  if (restText.startsWith("#")) {
+    return [key, null, restText];
+  }
+  const [rawValue, comment] = splitInlineComment(restText);
+  return [key, rawValue, comment];
+}
+function parseListLine(body) {
+  const stripped = body.replace(/^ +/, "");
+  if (stripped !== "-" && !stripped.startsWith("- ")) {
+    throw new Error(`not a list line: ${pyRepr(body)}`);
+  }
+  if (stripped === "-") {
+    return [null, null];
+  }
+  const rest = stripped.slice(2);
+  if (rest === "") {
+    return [null, null];
+  }
+  if (rest.startsWith("#")) {
+    return [null, rest];
+  }
+  return splitInlineComment(rest);
+}
+function pyRepr(s) {
+  const hasSingle = s.includes("'");
+  const hasDouble = s.includes('"');
+  const quote = hasSingle && !hasDouble ? '"' : "'";
+  let out = quote;
+  for (const ch of s) {
+    if (ch === "\\") {
+      out += "\\\\";
+    } else if (ch === quote) {
+      out += "\\" + quote;
+    } else if (ch === "\n") {
+      out += "\\n";
+    } else if (ch === "\r") {
+      out += "\\r";
+    } else if (ch === "	") {
+      out += "\\t";
+    } else {
+      out += ch;
+    }
+  }
+  out += quote;
+  return out;
+}
+function buildTree(lines) {
+  const root = makeNode({ indent: -1 });
+  const stack = [[root, null]];
+  let pending = [];
+  for (const line of lines) {
+    if (line.kind === "blank" || line.kind === "comment") {
+      pending.push(line.raw);
+      continue;
+    }
+    let parent;
+    for (; ; ) {
+      const top = stack[stack.length - 1];
+      if (top === void 0) {
+        throw new Error(`indent underflow at line ${line.number}`);
+      }
+      parent = top[0];
+      const fixedIndent = top[1];
+      const parentIndent = parent.indent;
+      if (line.indent > parentIndent) {
+        if (fixedIndent === null) {
+          stack[stack.length - 1] = [parent, line.indent];
+          break;
+        }
+        if (line.indent === fixedIndent) {
+          break;
+        }
+        if (line.indent > fixedIndent) {
+          throw new Error(
+            `unexpected over-indent at line ${line.number} (parent expects ${fixedIndent}, got ${line.indent})`
+          );
+        }
+      }
+      stack.pop();
+      if (stack.length === 0) {
+        throw new Error(`indent underflow at line ${line.number}`);
+      }
+    }
+    const node = lineToNode(line);
+    if (node.key !== null) {
+      for (let i = 0; i < parent.children.length; i++) {
+        const sib = parent.children[i];
+        if (sib !== void 0 && sib.key === node.key && !sib.is_list_item) {
+          parent.children.splice(i, 1);
+          break;
+        }
+      }
+    }
+    parent.children.push(node);
+    stack.push([node, null]);
+    if (pending.length > 0) {
+      node.leading = pending;
+      pending = [];
+    }
+  }
+  if (pending.length > 0) {
+    root.trailing = pending;
+  }
+  return root;
+}
+function lineToNode(line) {
+  if (line.kind === "list") {
+    const [rawValue2, inline2] = parseListLine(line.body);
+    return makeNode({
+      key: null,
+      indent: line.indent,
+      raw_value: rawValue2,
+      inline_comment: inline2,
+      is_list_item: true,
+      header_line: line.raw,
+      origin_line: line.number,
+      line_ending: line.line_ending
+    });
+  }
+  const [key, rawValue, inline] = parseMappingLine(line.body);
+  return makeNode({
+    key,
+    indent: line.indent,
+    raw_value: rawValue,
+    inline_comment: inline,
+    is_list_item: false,
+    header_line: line.raw,
+    origin_line: line.number,
+    line_ending: line.line_ending
+  });
+}
+function parse(text) {
+  if (text === "") {
+    return makeNode({ indent: -1 });
+  }
+  return buildTree(tokenise(text));
+}
+
+// src/scripts/_cli/cmd_settings_check.ts
+var DEFAULT_PATH = ".agent-settings.yml";
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`ArgparseExit(${code})`);
+    this.name = "ArgparseExit";
+    this.code = code;
+  }
+};
+function _stdoutSink() {
+  return { write: (t) => process.stdout.write(t) };
+}
+function _stderrSink() {
+  return { write: (t) => process.stderr.write(t) };
+}
+function _print(out, line = "") {
+  out.write(line + "\n");
+}
+function _ljust(s, width) {
+  const len = [...s].length;
+  if (len >= width) return s;
+  return s + " ".repeat(width - len);
+}
+function _isPyWs(code) {
+  return code === 9 || // \t
+  code === 10 || // \n
+  code === 11 || // \v
+  code === 12 || // \f
+  code === 13 || // \r
+  code === 28 || code === 29 || code === 30 || code === 31 || code === 32 || // space
+  code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+}
+function _pyStrip(s) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && _isPyWs(s.charCodeAt(start))) start += 1;
+  while (end > start && _isPyWs(s.charCodeAt(end - 1))) end -= 1;
+  return s.slice(start, end);
+}
+function _leadWsLen(s) {
+  let i = 0;
+  while (i < s.length && (s[i] === " " || s[i] === "	")) i += 1;
+  return i;
+}
+function _splitlines(text) {
+  if (text === "") return [];
+  const out = [];
+  let cur = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    const code = text.charCodeAt(i);
+    if (ch === "\r") {
+      if (text[i + 1] === "\n") i += 1;
+      out.push(cur);
+      cur = "";
+    } else if (ch === "\n" || code === 11 || code === 12 || code === 28 || code === 29 || code === 30 || code === 133 || code === 8232 || code === 8233) {
+      out.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur !== "") out.push(cur);
+  return out;
+}
+var _PRESCAN_RULES = [
+  [
+    "multi-doc separator",
+    /^(---|\.\.\.)\s*(#.*)?$/,
+    "remove the separator \u2014 one YAML document per file only."
+  ],
+  ["complex key", /^\?\s/, "rewrite as a plain ``key: value`` mapping line."],
+  [
+    "block-scalar indicator",
+    /:\s*[|>][+-]?\s*(#.*)?$/,
+    "inline the value as a single-line quoted scalar."
+  ],
+  ["tagged scalar", /:\s*!!?[A-Za-z_]/, "remove the ``!tag``; the parser does not honour it."],
+  [
+    "anchor / alias",
+    /:\s*[&*][A-Za-z_]/,
+    "expand the anchor inline \u2014 anchors / aliases are not supported."
+  ],
+  [
+    "nested flow-mapping",
+    /:\s*\{[^}]*:[^}]*\}/,
+    "rewrite as a block-style nested mapping (indented child keys)."
+  ]
+];
+function _scan_line(stripped) {
+  if (!stripped || stripped.startsWith("#")) {
+    return null;
+  }
+  for (const [label, pattern, hint] of _PRESCAN_RULES) {
+    if (pattern.test(stripped)) {
+      return [label, hint];
+    }
+  }
+  return null;
+}
+function _scan_text(text) {
+  const findings = [];
+  const lines = _splitlines(text);
+  for (let idx = 0; idx < lines.length; idx++) {
+    const raw = lines[idx];
+    const lineno = idx + 1;
+    const stripped = _pyStrip(raw);
+    const lead = raw.slice(0, _leadWsLen(raw));
+    if (lead.includes("	")) {
+      findings.push({
+        line: lineno,
+        kind: "tab in indent",
+        verdict: "not supported",
+        hint: "replace leading tabs with 2 or 4 spaces."
+      });
+      continue;
+    }
+    const hit = _scan_line(stripped);
+    if (hit !== null) {
+      const [label, hint] = hit;
+      findings.push({
+        line: lineno,
+        kind: label,
+        verdict: "not supported",
+        hint
+      });
+    }
+  }
+  return findings;
+}
+function _format(finding) {
+  return `  \u274C  line:${_ljust(String(finding.line), 4)}  ${_ljust(finding.kind, 22)}  ${_ljust(finding.verdict, 14)}  ${finding.hint}`;
+}
+function _parse(argv, out, err) {
+  const prog = "agent-config settings:check";
+  const usage = `usage: ${prog} [-h] [--path PATH] [--allow-missing]
+${" ".repeat(35)}[--quiet]
+`;
+  const emitError = (msg) => {
+    err.write(usage);
+    err.write(`${prog}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  const opts = { path: DEFAULT_PATH, allow_missing: false, quiet: false };
+  let i = 0;
+  while (i < argv.length) {
+    const tok = argv[i];
+    if (tok === "-h" || tok === "--help") {
+      out.write(usage);
+      throw new ArgparseExit(0);
+    } else if (tok === "--path") {
+      const val = argv[i + 1];
+      if (val === void 0) {
+        emitError("argument --path: expected one argument");
+      }
+      opts.path = val;
+      i += 2;
+    } else if (tok.startsWith("--path=")) {
+      opts.path = tok.slice("--path=".length);
+      i += 1;
+    } else if (tok === "--allow-missing") {
+      opts.allow_missing = true;
+      i += 1;
+    } else if (tok === "--quiet") {
+      opts.quiet = true;
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  return opts;
+}
+function main(argv = null, options = {}) {
+  const out = options.out ?? _stdoutSink();
+  const err = options.err ?? _stderrSink();
+  const opts = _parse(argv ?? process.argv.slice(2), out, err);
+  const target = opts.path;
+  let isFile;
+  try {
+    isFile = fs.statSync(target).isFile();
+  } catch {
+    isFile = false;
+  }
+  if (!isFile) {
+    if (opts.allow_missing) {
+      if (!opts.quiet) {
+        _print(out, `\u2705  ${target}: file absent (allow-missing).`);
+      }
+      return 0;
+    }
+    _print(err, `\u274C  ${target}: file not found.`);
+    _print(err, "    Run `./agent-config sync-agent-settings` to create it.");
+    return 2;
+  }
+  let text;
+  try {
+    text = fs.readFileSync(target, { encoding: "utf-8" });
+  } catch (exc) {
+    _print(err, `\u274C  ${target}: cannot read: ${exc.message}`);
+    return 2;
+  }
+  const findings = _scan_text(text);
+  if (findings.length === 0) {
+    try {
+      parse(text);
+    } catch (exc) {
+      findings.push({
+        line: 0,
+        kind: "parser",
+        verdict: "not supported",
+        hint: String(exc.message)
+      });
+    }
+  }
+  if (findings.length === 0) {
+    if (!opts.quiet) {
+      _print(
+        out,
+        `\u2705  ${target}: inside the supported subset (docs/contracts/settings-sync-yaml-subset.md).`
+      );
+    }
+    return 0;
+  }
+  _print(err, `\u274C  ${target}: ${findings.length} finding(s) outside the supported subset.`);
+  for (const finding of findings) {
+    _print(err, _format(finding));
+  }
+  _print(err, "");
+  _print(err, "    Contract: docs/contracts/settings-sync-yaml-subset.md");
+  return 1;
+}
+var _HERE = fileURLToPath(import.meta.url);
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  try {
+    process.exitCode = main(process.argv.slice(2));
+  } catch (exc) {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+export {
+  main
+};