@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/index-e9z7s5hh.js

@@ -0,0 +1,641 @@
+import {
+  legacyName,
+  legacyWarnings2,
+  legacyFile
+} from "./index-g18nxyn7.js";
+
+// config/config.ts
+function defineConfig2(config) {
+  return config;
+}
+// config/legacy-ps.ts
+import {
+  NodePs
+} from "../../core/system/index.js";
+class LegacyNamesPs {
+  inner;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  get platform() {
+    return this.inner.platform;
+  }
+  get pid() {
+    return this.inner.pid;
+  }
+  get hostname() {
+    return this.inner.hostname;
+  }
+  get args() {
+    return this.inner.args;
+  }
+  get self() {
+    return this.inner.self;
+  }
+  env(name) {
+    const value = this.inner.env(name);
+    const old = legacyName(name);
+    if (value !== undefined || old === null) {
+      return value;
+    }
+    const legacy = this.inner.env(old);
+    if (legacy !== undefined) {
+      legacyWarnings2.once(old, name);
+    }
+    return legacy;
+  }
+  columns() {
+    return this.inner.columns();
+  }
+  alive(pid) {
+    return this.inner.alive(pid);
+  }
+  spawn(argv, opts) {
+    return this.inner.spawn(argv, withLegacyEnv(opts));
+  }
+  spawnCapture(argv, opts) {
+    return this.inner.spawnCapture(argv, withLegacyEnv(opts));
+  }
+  start(argv, opts) {
+    return this.inner.start(argv, withLegacyEnv(opts));
+  }
+  startOnTerminal(argv, opts) {
+    return this.inner.startOnTerminal(argv, withLegacyEnv(opts));
+  }
+  processes() {
+    return this.inner.processes();
+  }
+  listening() {
+    return this.inner.listening();
+  }
+  cwd() {
+    return this.inner.cwd();
+  }
+  cd(path) {
+    this.inner.cd(path);
+  }
+  exit(code) {
+    this.inner.exit(code);
+  }
+  on(signal, handler) {
+    return this.inner.on(signal, handler);
+  }
+  once(event, handler) {
+    return this.inner.once(event, handler);
+  }
+}
+function systemPs2() {
+  return new LegacyNamesPs(new NodePs);
+}
+function withLegacyEnv(opts) {
+  if (opts === undefined || opts.env === undefined && opts.unset === undefined) {
+    return opts;
+  }
+  const env = { ...opts.env };
+  for (const [name, value] of Object.entries(opts.env ?? {})) {
+    const old = legacyName(name);
+    if (old !== null && !(old in env)) {
+      env[old] = value;
+    }
+  }
+  const unset = (opts.unset ?? []).flatMap((name) => {
+    const old = legacyName(name);
+    return old === null ? [name] : [name, old];
+  });
+  return {
+    ...opts,
+    ...opts.env === undefined ? {} : { env },
+    ...opts.unset === undefined ? {} : { unset }
+  };
+}
+// config/load.ts
+import { realpath } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { NodeFs as NodeFs2 } from "../../core/system/index.js";
+
+// git.ts
+import { NodeFs, NodePs as NodePs2 } from "../../core/system/index.js";
+
+// git-identity.ts
+async function authorOf(runner, cwd) {
+  const name = (await runner.git(cwd, ["config", "user.name"])).stdout.trim();
+  const email = (await runner.git(cwd, ["config", "user.email"])).stdout.trim();
+  return name === "" || email === "" ? null : { name, email };
+}
+async function fallbackIdentity(runner, cwd, given) {
+  const set = async (key) => (await runner.git(cwd, ["config", key])).stdout.trim() !== "";
+  const [name, email] = await Promise.all([
+    set("user.name"),
+    set("user.email")
+  ]);
+  const author = name && email ? null : await given?.author();
+  return [
+    ...name ? [] : ["-c", `user.name=${author?.name ?? "splates"}`],
+    ...email ? [] : ["-c", `user.email=${author?.email ?? "splates@localhost"}`]
+  ];
+}
+
+// git-process.ts
+var resolvedGit;
+function gitBinary() {
+  if (resolvedGit !== undefined) {
+    return resolvedGit;
+  }
+  resolvedGit = "git";
+  if (process.platform === "darwin" && Bun.which("git") === "/usr/bin/git") {
+    try {
+      const found = Bun.spawnSync(["xcrun", "--find", "git"], {
+        stdout: "pipe",
+        stderr: "ignore"
+      });
+      const path = found.stdout.toString().trim();
+      if (found.exitCode === 0 && path !== "" && path !== "/usr/bin/git") {
+        resolvedGit = path;
+      }
+    } catch {}
+  }
+  return resolvedGit;
+}
+function processGit(ps) {
+  return {
+    git: async (cwd, args, env) => {
+      const child = ps.start([gitBinary(), "-C", cwd, ...args], env === undefined ? undefined : { env });
+      const [exitCode, stdout, stderr] = await Promise.all([
+        child.exited,
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+        child.stdin.close().catch(() => {
+          return;
+        })
+      ]);
+      return { code: exitCode, stdout, stderr };
+    }
+  };
+}
+
+// git.ts
+class Git {
+  root;
+  fs;
+  runner;
+  identity;
+  constructor(root, opts = {}) {
+    this.root = root;
+    this.fs = opts.fs ?? new NodeFs;
+    this.runner = opts.run ?? processGit(opts.ps ?? new NodePs2);
+    this.identity = opts.identity;
+  }
+  author() {
+    return authorOf(this.runner, this.root);
+  }
+  at(root) {
+    return new Git(root, {
+      fs: this.fs,
+      run: this.runner,
+      ...this.identity === undefined ? {} : { identity: this.identity }
+    });
+  }
+  async run(cwd, ...args) {
+    const { code, stdout, stderr } = await this.runner.git(cwd, [
+      "--no-optional-locks",
+      ...args
+    ]);
+    return { code, stdout: stdout.trim(), stderr: stderr.trim() };
+  }
+  async runWith(cwd, args, env) {
+    const { code, stdout, stderr } = await this.runner.git(cwd, args, { GIT_TERMINAL_PROMPT: "0", ...env });
+    return { code, 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) {
+    if (await this.fs.exists(`${this.root}/.git/refs/heads/${branch}`)) {
+      return true;
+    }
+    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.runner.git(cwd, [
+      "--no-optional-locks",
+      "diff",
+      "--no-color",
+      "--no-ext-diff",
+      ...args
+    ]);
+    const { code: 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) : [];
+  }
+  async rebase(cwd, onto) {
+    return this.run(cwd, ...await fallbackIdentity(this.runner, cwd, this.identity), "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);
+  }
+  async commitAll(cwd, message) {
+    const added = await this.run(cwd, "add", "--all");
+    return added.code === 0 ? this.commit(cwd, "--no-verify", "--quiet", "-m", message) : added;
+  }
+  async commit(cwd, ...args) {
+    return this.run(cwd, ...await fallbackIdentity(this.runner, cwd, this.identity), "commit", ...args);
+  }
+  async squash(cwd, base, message) {
+    const fork = await this.run(cwd, "merge-base", base, "HEAD");
+    if (fork.code !== 0) {
+      return fork;
+    }
+    const head = await this.head(cwd);
+    if (fork.stdout === head) {
+      return null;
+    }
+    const reset = await this.run(cwd, "reset", "--soft", fork.stdout);
+    if (reset.code !== 0) {
+      return reset;
+    }
+    const committed = await this.commit(cwd, "--quiet", "-m", message);
+    if (committed.code !== 0) {
+      await this.run(cwd, "reset", "--soft", head);
+    }
+    return committed;
+  }
+  async remoteUrl(remote) {
+    const { code, stdout } = await this.run(this.root, "remote", "get-url", remote);
+    return code === 0 && stdout !== "" ? stdout : null;
+  }
+  async tracked(ref, paths) {
+    const { code, stdout } = await this.run(this.root, "ls-tree", "--name-only", ref, "--", ...paths);
+    return code === 0 ? lines(stdout) : [];
+  }
+  push(cwd, args, env = {}) {
+    return this.runWith(cwd, ["push", ...args], env);
+  }
+  fetch(cwd, args, env = {}) {
+    return this.runWith(cwd, ["fetch", "--quiet", "--no-tags", ...args], env);
+  }
+  async remoteHeads(remote, refs) {
+    const { code, stdout } = await this.runWith(this.root, ["ls-remote", remote, ...refs], {});
+    if (code !== 0) {
+      return null;
+    }
+    const heads = new Map;
+    for (const line of lines(stdout.trim())) {
+      const [commit, ref] = line.split("\t");
+      if (commit && ref) {
+        heads.set(ref, commit);
+      }
+    }
+    return heads;
+  }
+  async isAncestor(ancestor, commit) {
+    const { code } = await this.run(this.root, "merge-base", "--is-ancestor", ancestor, commit);
+    return code === 0;
+  }
+  async hasCommit(commit) {
+    const { code } = await this.run(this.root, "cat-file", "-e", `${commit}^{commit}`);
+    return code === 0;
+  }
+  async commonDir() {
+    const path = await this.out(this.root, "rev-parse", "--path-format=absolute", "--git-common-dir");
+    if (!path) {
+      throw new Error("git rev-parse --git-common-dir returned an empty path");
+    }
+    return path;
+  }
+  async worktreeGitDir(worktree) {
+    const dotGit = `${worktree}/.git`;
+    if (await this.fs.exists(`${dotGit}/HEAD`)) {
+      return dotGit;
+    }
+    const raw = await this.fs.read(dotGit).catch(() => "");
+    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(`
+`);
+}
+
+// config/load.ts
+var ARTIFACT_LIMITS2 = {
+  file: 50 * 1024 * 1024,
+  conversation: 250 * 1024 * 1024,
+  project: 2 * 1024 * 1024 * 1024
+};
+var CONFIG_FILE2 = "splates.config.ts";
+async function loadConfig2(root, opts = {}) {
+  const found = renamedSettings(await new ConfigFiles2(opts.fs).read(root));
+  const trunk = found.trunk ?? await (opts.git ?? new Git(root)).defaultBranch() ?? "main";
+  const config = { ...defaults(root, trunk), ...found };
+  return config;
+}
+function renamedSettings(found) {
+  const { todoStalenessMs, ...rest } = found;
+  return todoStalenessMs === undefined || rest.taskStalenessMs !== undefined ? rest : { ...rest, taskStalenessMs: todoStalenessMs };
+}
+function defaults(root, trunk) {
+  return {
+    trunk,
+    remote: null,
+    worktreeRoot: resolve(root, "..", `${basename(root)}-splates.noindex`),
+    postCheckout: null,
+    postRewrite: null,
+    preMerge: null,
+    preLock: null,
+    ship: null,
+    shipStatus: null,
+    afterBump: null,
+    on: {},
+    leaseStalenessMs: 90000,
+    mergeRetryCount: 5,
+    mergeConflictCount: 10,
+    removedCapacity: 50,
+    finishedCapacity: 500,
+    logCapacity: 1000,
+    taskStalenessMs: 30 * 24 * 60 * 60 * 1000,
+    attachmentCapacity: 100 * 1024 * 1024,
+    artifactFileCapacity: ARTIFACT_LIMITS2.file,
+    artifactConversationCapacity: ARTIFACT_LIMITS2.conversation,
+    artifactProjectCapacity: ARTIFACT_LIMITS2.project,
+    vet: "vet/bin/vet",
+    tunnel: null,
+    platform: null,
+    replica: null,
+    dictationWords: [],
+    evals: null
+  };
+}
+
+class ConfigFiles2 {
+  fs;
+  constructor(fs = new NodeFs2) {
+    this.fs = fs;
+  }
+  async read(root) {
+    return await this.importConfig(root);
+  }
+  importConfig(root) {
+    return this.importDefault(root, CONFIG_FILE2);
+  }
+  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;
+    }
+    legacyWarnings2.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 ?? {};
+  }
+}
+// config/source.ts
+function typedConfig2(source) {
+  const imported = source.match(DEFINE_CONFIG_IMPORT);
+  const code = [...codeOf(source)];
+  const calls = code.filter(({ index }, at) => source.startsWith("defineConfig(", index) && !/[\w$.]/.test(source[code[at - 1]?.index ?? -1] ?? ""));
+  if (imported?.index === undefined || calls.length !== 1) {
+    return null;
+  }
+  const from = imported.index;
+  const [call] = calls;
+  const open = call.index + "defineConfig".length;
+  const close = code.find(({ index, depth }) => index > open && source[index] === ")" && depth === call.depth);
+  if (close === undefined) {
+    return null;
+  }
+  return source.slice(0, from) + CONFIG_IMPORT + source.slice(from + imported[0].length, call.index) + source.slice(open + 1, close.index).trim() + " satisfies ConfigFile" + source.slice(close.index + 1);
+}
+var CONFIG_IMPORT = `import type { ConfigFile } from ${JSON.stringify("@stringsync/splates/config")};`;
+var DEFINE_CONFIG_IMPORT = /import\s*\{\s*defineConfig\s*\}\s*from\s*["'](?:@stringsync\/)?splates(?:-server)?\/config["'];?/;
+function* codeOf(source) {
+  const open = [];
+  let i = 0;
+  let template = false;
+  while (i < source.length) {
+    const char = source[i];
+    if (template) {
+      if (char === "\\") {
+        i += 2;
+      } else if (char === "`") {
+        template = false;
+        i++;
+      } else if (source.startsWith("${", i)) {
+        open.push("${");
+        template = false;
+        i += 2;
+      } else {
+        i++;
+      }
+      continue;
+    }
+    if (source.startsWith("//", i)) {
+      const end = source.indexOf(`
+`, i);
+      i = end === -1 ? source.length : end;
+    } else if (source.startsWith("/*", i)) {
+      const end = source.indexOf("*/", i + 2);
+      i = end === -1 ? source.length : end + 2;
+    } else if (char === '"' || char === "'") {
+      yield { index: i, depth: open.length };
+      i++;
+      while (i < source.length && source[i] !== char) {
+        i += source[i] === "\\" ? 2 : 1;
+      }
+      i++;
+    } else if (char === "`") {
+      template = true;
+      i++;
+    } else if (char === "}" && open.at(-1) === "${") {
+      open.pop();
+      template = true;
+      i++;
+    } else {
+      if ("{([".includes(char)) {
+        open.push(char);
+      } else if ("})]".includes(char)) {
+        open.pop();
+      }
+      yield { index: i, depth: open.length };
+      i++;
+    }
+  }
+}
+export { defineConfig2, systemPs2, processGit, Git, ARTIFACT_LIMITS2, CONFIG_FILE2, loadConfig2, ConfigFiles2, typedConfig2 };