@stringsync/splates 0.0.0-stage → 0.0.45

package/index-k73tsw5g.js

@@ -0,0 +1,101 @@
+// legacy-names.ts
+import { existsSync } from "node:fs";
+import { symlink } from "node:fs/promises";
+import { basename } from "node:path";
+var LEGACY = "arbor";
+var NEW_ENV = "SPLATES_";
+var OLD_ENV = "ARBOR_";
+function legacyName(name) {
+  return name.startsWith(NEW_ENV) ? `${OLD_ENV}${name.slice(NEW_ENV.length)}` : null;
+}
+function renamed(old) {
+  return old.startsWith(OLD_ENV) ? `${NEW_ENV}${old.slice(OLD_ENV.length)}` : null;
+}
+var LEGACY_CONFIG_FILE = "arbor.config.ts";
+var LEGACY_SYSTEMS_FILE = "arbor.systems.ts";
+var LEGACY_PLAN_FILE = "ARBOR.md";
+var LEGACY_DIR = "arbor";
+
+class Warnings {
+  #said = new Set;
+  once(name, instead) {
+    if (this.#said.has(name)) {
+      return;
+    }
+    this.#said.add(name);
+    process.stderr.write(`splates: ${name} is an old name, kept for one more release: use ${instead}
+`);
+  }
+}
+var legacyWarnings = new Warnings;
+function unmigrated(next, old) {
+  return !existsSync(next) && existsSync(old) ? old : next;
+}
+async function moveLegacyDir(old, next, { fs, log, link = symlink }) {
+  if (await fs.exists(next) || !await fs.exists(old) || await fs.isSymlink(old)) {
+    return false;
+  }
+  try {
+    await fs.rename(old, next);
+  } catch (error) {
+    if (await fs.exists(next)) {
+      return false;
+    }
+    throw error;
+  }
+  await link(basename(next), old);
+  log.info(`moved ${old} to ${next}, left a link behind`);
+  return true;
+}
+async function movePlan(tree, planFile, fs) {
+  const old = `${tree}/${LEGACY_PLAN_FILE}`;
+  const next = `${tree}/${planFile}`;
+  if (await fs.exists(old) && !await fs.exists(next)) {
+    await fs.rename(old, next);
+  }
+}
+function movedPath(path) {
+  return path.replace(`/.git/${LEGACY_DIR}/`, "/.git/splates/");
+}
+function legacyFile(file) {
+  const old = {
+    "splates.config.ts": LEGACY_CONFIG_FILE,
+    "splates.systems.ts": LEGACY_SYSTEMS_FILE
+  };
+  return old[file] ?? null;
+}
+async function renameLegacyFiles({
+  root,
+  fs,
+  ps,
+  log
+}) {
+  for (const next of ["splates.config.ts", "splates.systems.ts"]) {
+    const old = legacyFile(next);
+    if (old === null || !await fs.exists(`${root}/${old}`) || await fs.exists(`${root}/${next}`)) {
+      continue;
+    }
+    const { exitCode } = await ps.spawnCapture(["git", "mv", old, next], {
+      cwd: root
+    });
+    if (exitCode !== 0) {
+      await fs.rename(`${root}/${old}`, `${root}/${next}`);
+    }
+    const path = `${root}/${next}`;
+    await fs.write(path, (await fs.read(path)).replaceAll("@webappwiz/arbor", "@stringsync/splates"));
+    log.info(`renamed ${old} to ${next}`);
+  }
+  const manifest = await fs.read(`${root}/package.json`).catch(() => "");
+  if (manifest.includes('"@webappwiz/arbor"')) {
+    log.info("package.json names @webappwiz/arbor: install @stringsync/splates in its place");
+  }
+}
+async function removeLegacySkill(path, { fs, log }) {
+  if (!await fs.exists(path) || await fs.isSymlink(path)) {
+    return;
+  }
+  await fs.rm(path, { recursive: true });
+  log.info(`removed arbor's skill at ${path}: the splates skill replaces it`);
+}
+
+export { LEGACY, legacyName, renamed, LEGACY_PLAN_FILE, LEGACY_DIR, legacyWarnings, unmigrated, moveLegacyDir, movePlan, movedPath, legacyFile, renameLegacyFiles, removeLegacySkill };

package/index-kaa44k7q.js

@@ -0,0 +1,59 @@
+// exit.ts
+var EXIT = {
+  usage: 1,
+  conflict: 2,
+  tests_failed: 3,
+  lease_lost: 4,
+  budget_exhausted: 5,
+  lease_held: 6,
+  dirty: 7,
+  not_found: 8,
+  hook_failed: 9,
+  exists: 10,
+  orphaned: 11,
+  merge_failed: 12,
+  already_removed: 13,
+  timeout: 14,
+  blocked: 16,
+  cycle: 18,
+  outdated: 19,
+  uninitialized: 20,
+  too_large: 21,
+  dismissed: 22,
+  no_secret_store: 23,
+  cloudflare: 24,
+  requested: 25,
+  slots_full: 26,
+  slot_running: 27,
+  not_granted: 28,
+  agents_full: 29
+};
+
+class Exit extends Error {
+  reason;
+  data;
+  constructor(reason, message, data = {}) {
+    super(message);
+    this.reason = reason;
+    this.data = data;
+  }
+}
+function fail(reason, message, data = {}) {
+  throw new Exit(reason, message, data);
+}
+function exits() {
+  return async (ctx, next) => {
+    try {
+      await next(ctx);
+    } catch (e) {
+      if (!(e instanceof Exit)) {
+        throw e;
+      }
+      ctx.log.info(JSON.stringify({ reason: e.reason, ...e.data }));
+      ctx.log.error(e.message);
+      ctx.ps.exit(EXIT[e.reason]);
+    }
+  };
+}
+
+export { EXIT, Exit, fail, exits };