@stringsync/splates 0.0.0-stage → 0.0.45

package/index-4776671w.js

@@ -0,0 +1,698 @@
+import {
+  legacyWarnings,
+  legacyFile
+} from "./index-k73tsw5g.js";
+import {
+  fail
+} from "./index-kaa44k7q.js";
+
+// systems.ts
+import { NodeFs as NodeFs3, NodeGlob } from "webappwiz/system";
+import { z } from "zod";
+
+// load-config.ts
+import { realpath } from "node:fs/promises";
+import { basename as basename3, resolve as resolve3 } from "node:path";
+import { NodeFs as NodeFs2 } from "webappwiz/system";
+
+// artifacts.ts
+import { basename as basename2, dirname, resolve as resolve2 } from "node:path";
+import { UuidProvider as UuidProvider2 } from "webappwiz/id";
+
+// attachments.ts
+import { basename, resolve } from "node:path";
+import { UuidProvider } from "webappwiz/id";
+class Attachments {
+  dir;
+  fs;
+  ids;
+  constructor(dir, fs, ids = new UuidProvider) {
+    this.dir = dir;
+    this.fs = fs;
+    this.ids = ids;
+  }
+  async store(files) {
+    if (files.length === 0) {
+      return [];
+    }
+    await this.fs.mkdir(this.dir);
+    const stored = [];
+    for (const file of files) {
+      const path = `${this.dir}/${this.ids.next()}-${safe(file.name)}`;
+      await this.fs.writeBytes(path, file.bytes);
+      stored.push(path);
+    }
+    return stored;
+  }
+  async held() {
+    const names = await this.fs.readdir(this.dir).catch(() => []);
+    const held = [];
+    for (const name of names.sort()) {
+      const path = `${this.dir}/${name}`;
+      held.push({ path, bytes: (await this.fs.stat(path)).size });
+    }
+    return held;
+  }
+  owns(path) {
+    return resolve(path).startsWith(`${resolve(this.dir)}/`);
+  }
+  async remove(paths) {
+    for (const path of paths.filter((path) => this.owns(path))) {
+      await this.fs.rm(path, { force: true });
+    }
+  }
+  async clear() {
+    await this.fs.rm(this.dir, { recursive: true, force: true });
+  }
+}
+async function readFiles({ fs, ps }, paths) {
+  const read = [];
+  for (const given of paths) {
+    const path = resolve(ps.cwd(), given);
+    const bytes = await fs.readBytes(path).catch(() => null);
+    if (bytes === null) {
+      fail("usage", `cannot read ${path}: nothing was changed`, {
+        file: path
+      });
+    }
+    read.push({ name: basename(path), bytes });
+  }
+  return read;
+}
+function safe(name) {
+  return basename(name).replace(/[^\w.-]+/g, "-") || "attachment";
+}
+async function folderBytes(fs, dir) {
+  let total = 0;
+  for (const name of await fs.readdir(dir).catch(() => [])) {
+    const path = `${dir}/${name}`;
+    const found = await fs.stat(path);
+    total += found.isDirectory() ? await folderBytes(fs, path) : found.size;
+  }
+  return total;
+}
+
+// artifacts.ts
+class Artifacts {
+  deps;
+  dir;
+  conversations;
+  ids;
+  queue = Promise.resolve();
+  constructor(log, deps) {
+    this.deps = deps;
+    this.dir = `${resolve2(log.replace(/\.jsonl$/, ""))}/artifacts`;
+    this.conversations = dirname(resolve2(log));
+    this.ids = deps.ids ?? new UuidProvider2;
+  }
+  get held() {
+    return this.deps.held();
+  }
+  add(file) {
+    const { room } = this.deps;
+    if (room === undefined) {
+      return this.serially(async () => {
+        const size = await this.admit(file);
+        const { fs, limits } = this.deps;
+        const project = await projectBytes(fs, this.conversations) + size;
+        if (project > limits.project) {
+          tooLarge("the project", file.name.trim(), project, limits.project);
+        }
+        return this.keep(file);
+      });
+    }
+    return room.hold(async () => {
+      await room.make(await this.admit(file), file.name.trim());
+      return this.serially(() => this.keep(file));
+    });
+  }
+  remove(name) {
+    return this.serially(async () => {
+      const artifact = this.find(name);
+      if (artifact.removedAt !== null) {
+        fail("not_found", `artifact '${name}' is already removed`, { name });
+      }
+      await this.deps.record({ type: "remove", name, at: this.deps.now() });
+    });
+  }
+  delete(name, version, why) {
+    return this.serially(async () => {
+      const kept = this.find(name).versions.find((each) => each.version === version);
+      if (kept === undefined) {
+        fail("not_found", `artifact '${name}' has no version ${version}`, {
+          name,
+          version
+        });
+      }
+      if (kept.gone === null) {
+        await this.drop(name, kept, why);
+      }
+    });
+  }
+  archive() {
+    return this.serially(async () => {
+      for (const artifact of this.deps.held()) {
+        for (const version of artifact.versions) {
+          if (version.gone === null && !shown(artifact, version)) {
+            await this.drop(artifact.name, version, "archived");
+          }
+        }
+      }
+    });
+  }
+  async read(name, version) {
+    const artifact = this.deps.held().find((each) => each.name === name);
+    const wanted = version ?? artifact?.current;
+    const kept = artifact?.versions.find((each) => each.version === wanted);
+    if (kept === undefined || kept.gone !== null) {
+      return null;
+    }
+    const bytes = await this.deps.fs.readBytes(`${this.dir}/${kept.file}`).catch(() => null);
+    return bytes === null ? null : { bytes, mimeType: kept.mimeType };
+  }
+  async admit(file) {
+    const name = file.name.trim();
+    if (name === "") {
+      fail("usage", "an artifact needs a name: nothing was changed");
+    }
+    const size = file.bytes.length;
+    const { limits } = this.deps;
+    if (size > limits.file) {
+      fail("too_large", `'${name}' is ${megabytes(size)}, past the ${megabytes(limits.file)} an artifact may be: nothing was changed`, { name, bytes: size, capacity: limits.file });
+    }
+    const attached = await folderBytes(this.deps.fs, `${dirname(this.dir)}/attached`);
+    const conversation = kept(this.deps.held()) + attached + size;
+    if (conversation > limits.conversation) {
+      tooLarge("this conversation", name, conversation, limits.conversation);
+    }
+    return size;
+  }
+  async keep(file) {
+    const name = file.name.trim();
+    const stored = `${this.ids.next()}-${safe2(name)}`;
+    await this.deps.fs.mkdir(this.dir);
+    await this.deps.fs.writeBytes(`${this.dir}/${stored}`, file.bytes);
+    await this.deps.record({
+      type: "add",
+      name,
+      file: stored,
+      mimeType: file.mimeType,
+      bytes: file.bytes.length,
+      addedAt: this.deps.now()
+    });
+    const added = this.find(name);
+    return added.versions[added.versions.length - 1];
+  }
+  async drop(name, version, why) {
+    await this.deps.fs.rm(`${this.dir}/${version.file}`, { force: true });
+    await this.deps.record({
+      type: "gone",
+      name,
+      version: version.version,
+      at: this.deps.now(),
+      why
+    });
+  }
+  find(name) {
+    const artifact = this.deps.held().find((each) => each.name === name);
+    if (artifact === undefined) {
+      fail("not_found", `this conversation holds no artifact '${name}'`, {
+        name
+      });
+    }
+    return artifact;
+  }
+  serially(work) {
+    const next = this.queue.then(work);
+    this.queue = next.catch(() => {});
+    return next;
+  }
+}
+var ARTIFACT_LIMITS = {
+  file: 50 * 1024 * 1024,
+  conversation: 250 * 1024 * 1024,
+  project: 2 * 1024 * 1024 * 1024
+};
+function artifactLimits(config) {
+  return {
+    file: config.artifactFileCapacity,
+    conversation: config.artifactConversationCapacity,
+    project: config.artifactProjectCapacity
+  };
+}
+function applyArtifact(artifacts, change) {
+  const artifact = artifacts.find((each) => each.name === change.name);
+  if (change.type === "add") {
+    const { type: _, name, ...added } = change;
+    const version = (artifact?.versions.length ?? 0) + 1;
+    const kept = { version, ...added, gone: null };
+    if (artifact === undefined) {
+      artifacts.push({
+        name,
+        current: version,
+        versions: [kept],
+        removedAt: null
+      });
+    } else {
+      artifact.versions.push(kept);
+      artifact.current = version;
+      artifact.removedAt = null;
+    }
+  } else if (change.type === "remove") {
+    if (artifact !== undefined) {
+      artifact.removedAt = change.at;
+    }
+  } else {
+    const version = artifact?.versions.find((each) => each.version === change.version);
+    if (version !== undefined) {
+      version.gone = { at: change.at, why: change.why };
+    }
+  }
+}
+function kept(artifacts) {
+  return artifacts.flatMap((each) => each.versions).filter((each) => each.gone === null).reduce((sum, each) => sum + each.bytes, 0);
+}
+function shown(artifact, version) {
+  return artifact.removedAt === null && version.version === artifact.current;
+}
+async function projectBytes(fs, dir) {
+  let total = 0;
+  for (const entry of await fs.readdir(dir).catch(() => [])) {
+    total += await folderBytes(fs, `${dir}/${entry}/artifacts`);
+    total += await folderBytes(fs, `${dir}/${entry}/attached`);
+  }
+  return total;
+}
+function tooLarge(what, name, bytes, capacity) {
+  fail("too_large", `that would have ${what} hold ${megabytes(bytes)} of artifacts, past its ${megabytes(capacity)}: nothing was changed`, { name, bytes, capacity });
+}
+function safe2(name) {
+  return basename2(name).replace(/[^\w.-]+/g, "-") || "artifact";
+}
+function megabytes(bytes) {
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+// git.ts
+import { NodeFs, NodePs } from "webappwiz/system";
+
+class Git {
+  root;
+  ps;
+  fs;
+  constructor(root, opts = {}) {
+    this.root = root;
+    this.ps = opts.ps ?? new NodePs;
+    this.fs = opts.fs ?? new NodeFs;
+  }
+  async run(cwd, ...args) {
+    const { exitCode, stdout, stderr } = await this.ps.spawnCapture([
+      "git",
+      "--no-optional-locks",
+      "-C",
+      cwd,
+      ...args
+    ]);
+    return { code: exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  }
+  async out(cwd, ...args) {
+    const result = await this.run(cwd, ...args);
+    if (result.code !== 0) {
+      throw new Error(`git ${args.join(" ")}: ${result.stderr || result.stdout}`);
+    }
+    return result.stdout;
+  }
+  async branchExists(branch) {
+    const { code } = await this.run(this.root, "rev-parse", "--verify", "--quiet", `refs/heads/${branch}`);
+    return code === 0;
+  }
+  async defaultBranch() {
+    const { code, stdout } = await this.run(this.root, "symbolic-ref", "--short", "refs/remotes/origin/HEAD");
+    return code === 0 ? stdout.replace(/^origin\//, "") || null : null;
+  }
+  async currentBranch(cwd) {
+    const { code, stdout, stderr } = await this.run(cwd, "symbolic-ref", "--quiet", "--short", "HEAD");
+    if (code === 0) {
+      return stdout;
+    }
+    if (code === 1 || stderr.includes("not a git repository")) {
+      return null;
+    }
+    throw new Error(`git symbolic-ref HEAD: ${stderr || stdout}`);
+  }
+  head(cwd) {
+    return this.out(cwd, "rev-parse", "HEAD");
+  }
+  shortHead(cwd) {
+    return this.out(cwd, "rev-parse", "--short", "HEAD");
+  }
+  async porcelain(cwd) {
+    return lines(await this.out(cwd, "status", "--porcelain"));
+  }
+  async conflictedPaths(cwd) {
+    const out = await this.out(cwd, "diff", "--name-only", "--diff-filter=U").catch(() => "");
+    return lines(out);
+  }
+  async commitsAhead(trunk, branch) {
+    const result = await this.run(this.root, "rev-list", "--count", `${trunk}..${branch}`);
+    return result.code === 0 ? Number(result.stdout) : null;
+  }
+  async committedAt(ref) {
+    const { code, stdout } = await this.run(this.root, "log", "-1", "--format=%cI", ref, "--");
+    return code === 0 && stdout.trim() !== "" ? stdout.trim() : null;
+  }
+  async commitMessages(trunk, branch) {
+    const result = await this.run(this.root, "log", "--reverse", "--format=%B%x00", `${trunk}..${branch}`);
+    return result.code === 0 ? result.stdout.split("\x00").map((each) => each.trim()).filter(Boolean) : null;
+  }
+  async diff(trunk, branch, worktree) {
+    const base = await this.run(this.root, "merge-base", trunk, branch);
+    if (base.code !== 0) {
+      return null;
+    }
+    const raw = (cwd, ...args) => this.ps.spawnCapture([
+      "git",
+      "--no-optional-locks",
+      "-C",
+      cwd,
+      "diff",
+      "--no-color",
+      "--no-ext-diff",
+      ...args
+    ]);
+    const { exitCode, stdout } = await raw(worktree ?? this.root, base.stdout, ...worktree === null ? [branch] : []);
+    if (exitCode !== 0) {
+      return null;
+    }
+    if (worktree === null) {
+      return { text: stdout, uncommitted: [] };
+    }
+    const edited = await this.run(worktree, "diff", "--name-only", "HEAD");
+    const untracked = await this.run(worktree, "ls-files", "--others", "--exclude-standard");
+    if (edited.code !== 0 || untracked.code !== 0) {
+      return null;
+    }
+    let text = stdout;
+    for (const path of lines(untracked.stdout)) {
+      const added = await raw(worktree, "--no-index", "--", "/dev/null", path);
+      text += added.stdout;
+    }
+    return {
+      text,
+      uncommitted: [
+        ...new Set([...lines(edited.stdout), ...lines(untracked.stdout)])
+      ]
+    };
+  }
+  async changedFiles(trunk, branch, worktree) {
+    const committed = await this.run(this.root, "diff", "--name-only", `${trunk}...${branch}`);
+    if (committed.code !== 0) {
+      return null;
+    }
+    const paths = lines(committed.stdout);
+    if (worktree !== null) {
+      const edited = await this.run(worktree, "diff", "--name-only", "HEAD");
+      const added = await this.run(worktree, "ls-files", "--others", "--exclude-standard");
+      paths.push(...lines(edited.stdout), ...lines(added.stdout));
+    }
+    return [...new Set(paths)].sort();
+  }
+  async paths(cwd) {
+    const files = lines(await this.out(cwd, "ls-files", "--cached", "--others", "--exclude-standard"));
+    const found = new Set(files);
+    for (const file of files) {
+      const parts = file.split("/");
+      for (let depth = 1;depth < parts.length; depth++) {
+        found.add(`${parts.slice(0, depth).join("/")}/`);
+      }
+    }
+    return [...found].sort();
+  }
+  async log(ref, count) {
+    const { code, stdout } = await this.run(this.root, "log", `-${count}`, "--name-only", "--format=%x1e%H%x1f%aI%x1f%an%x1f%s", ref, "--");
+    if (code !== 0) {
+      return [];
+    }
+    return stdout.split("\x1E").filter((record) => record.trim() !== "").map((record) => {
+      const [head = "", ...files] = record.trim().split(`
+`);
+      const [hash = "", at = "", author = "", subject = ""] = head.split("\x1F");
+      return {
+        hash,
+        at,
+        author,
+        subject,
+        files: files.filter((file) => file !== "")
+      };
+    });
+  }
+  async files(ref) {
+    const { code, stdout } = await this.run(this.root, "ls-tree", "-r", "--name-only", ref);
+    return code === 0 ? lines(stdout) : [];
+  }
+  rebase(cwd, onto) {
+    return this.run(cwd, "rebase", onto);
+  }
+  resetHard(cwd, commit) {
+    return this.run(cwd, "reset", "--hard", commit);
+  }
+  checkout(branch) {
+    return this.run(this.root, "checkout", branch);
+  }
+  mergeFfOnly(cwd, branch) {
+    return this.run(cwd, "merge", "--ff-only", branch);
+  }
+  async worktreeFor(branch) {
+    const listing = await this.out(this.root, "worktree", "list", "--porcelain");
+    let path = null;
+    for (const line of listing.split(`
+`)) {
+      if (line.startsWith("worktree ")) {
+        path = line.slice("worktree ".length);
+      } else if (line === `branch refs/heads/${branch}`) {
+        return path;
+      }
+    }
+    return null;
+  }
+  addWorktree(branch, path, from) {
+    return this.run(this.root, "worktree", "add", "-b", branch, path, from);
+  }
+  removeWorktree(path) {
+    return this.run(this.root, "worktree", "remove", path, "--force");
+  }
+  pruneWorktrees() {
+    return this.run(this.root, "worktree", "prune");
+  }
+  deleteBranch(branch) {
+    return this.run(this.root, "branch", "-D", branch);
+  }
+  commonDir() {
+    return this.out(this.root, "rev-parse", "--path-format=absolute", "--git-common-dir");
+  }
+  async worktreeGitDir(worktree) {
+    const raw = await this.fs.read(`${worktree}/.git`).catch(() => null);
+    return raw?.trim().replace(/^gitdir:\s*/, "") ?? null;
+  }
+  async interruptedOps(worktree) {
+    const dir = await this.worktreeGitDir(worktree);
+    if (dir === null) {
+      return [];
+    }
+    const checks = [
+      ["rebase-merge", "rebase in progress"],
+      ["rebase-apply", "rebase in progress"],
+      ["MERGE_HEAD", "merge in progress"],
+      ["CHERRY_PICK_HEAD", "cherry-pick in progress"]
+    ];
+    const found = [];
+    for (const [entry, description] of checks) {
+      if (await this.fs.exists(`${dir}/${entry}`)) {
+        found.push(description);
+      }
+    }
+    return [...new Set(found)];
+  }
+}
+function lines(out) {
+  return out === "" ? [] : out.split(`
+`);
+}
+
+// load-config.ts
+var CONFIG_FILE = "splates.config.ts";
+async function loadConfig(root, opts = {}) {
+  const found = await new ConfigFiles(opts.fs).read(root);
+  const trunk = found.trunk ?? await (opts.git ?? new Git(root)).defaultBranch() ?? "main";
+  return { ...defaults(root, trunk), ...found };
+}
+function defaults(root, trunk) {
+  return {
+    trunk,
+    worktreeRoot: resolve3(root, "..", `${basename3(root)}-splates.noindex`),
+    postCheckout: null,
+    postRewrite: null,
+    preMerge: null,
+    leaseStalenessMs: 90000,
+    agentsPerAgent: 15,
+    mergeRetryCount: 3,
+    removedCapacity: 50,
+    logCapacity: 1000,
+    todoStalenessMs: 30 * 24 * 60 * 60 * 1000,
+    attachmentCapacity: 100 * 1024 * 1024,
+    artifactFileCapacity: ARTIFACT_LIMITS.file,
+    artifactConversationCapacity: ARTIFACT_LIMITS.conversation,
+    artifactProjectCapacity: ARTIFACT_LIMITS.project,
+    wiz: "bunx @webappwiz/cli",
+    tunnel: null
+  };
+}
+
+class ConfigFiles {
+  fs;
+  constructor(fs = new NodeFs2) {
+    this.fs = fs;
+  }
+  async read(root) {
+    const { systems: _, ...config } = await this.importConfig(root);
+    return config;
+  }
+  importConfig(root) {
+    return this.importDefault(root, CONFIG_FILE);
+  }
+  async found(root, file) {
+    const path = `${root}/${file}`;
+    if (await this.fs.exists(path)) {
+      return path;
+    }
+    const old = legacyFile(file);
+    if (old === null || !await this.fs.exists(`${root}/${old}`)) {
+      return null;
+    }
+    legacyWarnings.once(old, `${file}: run \`splates update\``);
+    return `${root}/${old}`;
+  }
+  async importDefault(root, file) {
+    const path = await this.found(root, file);
+    if (path === null) {
+      return {};
+    }
+    const version = Bun.hash(await this.fs.read(path)).toString(36);
+    const real = await realpath(path).catch(() => path);
+    const mod = await import(`${real}?v=${version}`).catch((cause) => {
+      throw new Error(`could not load ${path}: ${cause}. Its imports may be stale: try \`bun install\` in ${root}.`, { cause });
+    });
+    return mod.default ?? {};
+  }
+}
+
+// systems.ts
+var SYSTEMS_FILE2 = "splates.systems.ts";
+
+class Systems2 {
+  named;
+  glob;
+  constructor(named, glob) {
+    this.named = named;
+    this.glob = glob;
+  }
+  static async at(root, opts = {}) {
+    return Systems2.of(await readSystems2(root, opts.fs), opts.glob);
+  }
+  static of(systems, glob = new NodeGlob) {
+    return new Systems2(Object.entries(systems).map(([name, system]) => ({ name, ...system })), glob);
+  }
+  all() {
+    return this.named;
+  }
+  find(name) {
+    return this.named.find((system) => system.name === name || (system.aliases ?? []).includes(name)) ?? null;
+  }
+  touchedBy(paths) {
+    return this.named.filter((system) => paths.some((path) => this.contains(system, path)));
+  }
+  within(system, paths) {
+    return paths.filter((path) => this.contains(system, path));
+  }
+  unmatched(system, paths) {
+    return system.globs.filter((pattern) => !paths.some((path) => this.glob.matches(pattern, path)));
+  }
+  mentioned(text) {
+    const found = [];
+    for (const [, , called = ""] of text.matchAll(MENTION)) {
+      const system = this.find(called);
+      if (system !== null && !found.includes(system)) {
+        found.push(system);
+      }
+    }
+    return found;
+  }
+  unknown(text) {
+    return hashed2(text).filter((called) => !/^\d+$/.test(called) && this.find(called) === null);
+  }
+  contains(system, path) {
+    const matches = (pattern) => this.glob.matches(pattern, path);
+    return system.globs.some(matches) && !(system.ignore ?? []).some(matches);
+  }
+}
+var MENTION = /(^|\s)#([^\s#]*[^\s#.,;:!?)\]'"-])/g;
+function hashed2(text) {
+  const prose = text.replace(/```[\s\S]*?(```|$)|`[^`\n]*`/g, " ");
+  const found = [];
+  for (const [, , called = ""] of prose.matchAll(MENTION)) {
+    if (!found.includes(called)) {
+      found.push(called);
+    }
+  }
+  return found;
+}
+function mentionLine2(system) {
+  const aliases = system.aliases ?? [];
+  const ignore = system.ignore ?? [];
+  return [
+    `#${system.name}`,
+    aliases.length > 0 ? ` (${aliases.join(", ")})` : "",
+    ": ",
+    system.description === undefined ? "" : `${system.description.replace(/\.$/, "")}. Made of `,
+    system.globs.join(", "),
+    ignore.length > 0 ? `; not ${ignore.join(", ")}` : ""
+  ].join("");
+}
+function unknownLine2(name) {
+  return `#${name} names no system: find the code it means, and offer to name it as the splates skill's Systems section says.`;
+}
+var DESCRIPTION_MAX2 = 80;
+var SYSTEMS = z.record(z.string().min(1), z.strictObject({
+  description: z.string().min(1).max(DESCRIPTION_MAX2).refine((text) => !text.includes(`
+`), "must be one line").optional(),
+  aliases: z.array(z.string().min(1)).max(2).optional(),
+  globs: z.array(z.string().min(1)).min(1),
+  ignore: z.array(z.string().min(1)).optional()
+}));
+async function readSystems2(root, fs = new NodeFs3) {
+  const files = new ConfigFiles(fs);
+  if ((await files.importConfig(root)).systems !== undefined) {
+    throw new Error(`${root}/${CONFIG_FILE} names systems, which splates now reads from ${SYSTEMS_FILE2}: run \`splates update\` to move them`);
+  }
+  return checkSystems2(`${root}/${SYSTEMS_FILE2}`, await files.importDefault(root, SYSTEMS_FILE2));
+}
+function checkSystems2(path, systems) {
+  const parsed = SYSTEMS.safeParse(systems);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    throw new Error(`${path}: ${issue?.path.join(".")}: ${issue?.message}`);
+  }
+  const owners = new Map;
+  for (const [name, system] of Object.entries(parsed.data)) {
+    for (const called of [name, ...system.aliases ?? []]) {
+      const owner = owners.get(called);
+      if (owner !== undefined) {
+        throw new Error(`${path}: systems '${owner}' and '${name}' both answer to '${called}': give each its own names`);
+      }
+      owners.set(called, name);
+    }
+  }
+  return parsed.data;
+}
+
+export { Attachments, readFiles, folderBytes, Artifacts, ARTIFACT_LIMITS, artifactLimits, applyArtifact, shown, projectBytes, tooLarge, Git, CONFIG_FILE, loadConfig, ConfigFiles, SYSTEMS_FILE2, Systems2, hashed2, mentionLine2, unknownLine2, DESCRIPTION_MAX2, readSystems2, checkSystems2 };