@jondotsoy/envs 0.0.0-stage → 0.0.2

package/envs.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/envs.ts
+import { mkdir } from "fs/promises";
+import { basename, dirname, join } from "path";
+var {$ } = globalThis.Bun;
+var HELP = `Usage: envs <command>
+
+Commands:
+  init    Create the .envs/ directory (.gitignore, values.yml)
+  pull    Read each worktree's .env and write it into .envs/values.yml
+  push    Write defaults and .envs/values.yml into the .env of each worktree
+  edit    Pull, open .envs/values.yml in VS Code (code -w), then push
+  help    Show this help message
+`;
+var defaultContext = () => ({
+  cwd: process.cwd(),
+  log: (message) => console.log(message),
+  error: (message) => console.error(message),
+  openEditor: async (path) => {
+    const proc = Bun.spawn(["code", "-w", path], {
+      env: { ...process.env },
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    return await proc.exited;
+  }
+});
+async function findRoot(cwd) {
+  const result = await $`git rev-parse --path-format=absolute --git-common-dir`.cwd(cwd).nothrow().quiet();
+  if (result.exitCode !== 0)
+    return cwd;
+  return dirname(result.stdout.toString().trim());
+}
+async function listWorktrees(cwd) {
+  const out = await $`git worktree list --porcelain`.cwd(cwd).text();
+  return out.trim().split(`
+
+`).map((block) => {
+    const lines = block.split(`
+`);
+    const path = lines.find((l) => l.startsWith("worktree ")).slice(9);
+    const branch = lines.find((l) => l.startsWith("branch "));
+    return {
+      path,
+      name: branch ? branch.slice("branch refs/heads/".length) : basename(path)
+    };
+  });
+}
+function parseDotenv(text) {
+  const result = {};
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    const match = line.match(/^(?:export\s+)?([\w.-]+)\s*=\s*(.*)$/);
+    if (!match)
+      continue;
+    let value = match[2].trim();
+    const quote = value[0];
+    if ((quote === '"' || quote === "'") && value.lastIndexOf(quote) > 0) {
+      value = value.slice(1, value.lastIndexOf(quote));
+    } else {
+      value = value.replace(/\s+#.*$/, "");
+    }
+    result[match[1]] = value;
+  }
+  return result;
+}
+function formatDotenvValue(value) {
+  if (value !== "" && !/[\s#"'\\$]/.test(value))
+    return value;
+  return value.includes('"') ? `'${value}'` : `"${value}"`;
+}
+function updateDotenv(text, entries) {
+  const pending = new Map(Object.entries(entries));
+  const lines = text === "" ? [] : text.replace(/\n$/, "").split(`
+`);
+  const updated = lines.map((line) => {
+    const key = line.trim().match(/^(?:export\s+)?([\w.-]+)\s*=/)?.[1];
+    if (key === undefined || !pending.has(key))
+      return line;
+    const value = pending.get(key);
+    pending.delete(key);
+    return `${key}=${formatDotenvValue(value)}`;
+  });
+  for (const [key, value] of pending) {
+    updated.push(`${key}=${formatDotenvValue(value)}`);
+  }
+  return updated.join(`
+`) + `
+`;
+}
+async function readValues(ctx) {
+  const path = join(await findRoot(ctx.cwd), ".envs/values.yml");
+  if (!await Bun.file(path).exists()) {
+    ctx.error(`${path} not found. Run \`envs init\` first.`);
+    return;
+  }
+  const values = Bun.YAML.parse(await Bun.file(path).text()) ?? {};
+  return { path, values };
+}
+async function init(ctx) {
+  const root = await findRoot(ctx.cwd);
+  const files = { ".envs/.gitignore": `*
+`, ".envs/values.yml": "" };
+  await mkdir(join(root, ".envs"), { recursive: true });
+  for (const [name, content] of Object.entries(files)) {
+    const path = join(root, name);
+    if (await Bun.file(path).exists()) {
+      ctx.log(`${path} already exists`);
+    } else {
+      await Bun.write(path, content);
+      ctx.log(`Created ${path}`);
+    }
+  }
+  return 0;
+}
+async function push(ctx) {
+  const read = await readValues(ctx);
+  if (!read)
+    return 1;
+  const { values } = read;
+  for (const { name, path } of await listWorktrees(ctx.cwd)) {
+    const entries = {};
+    for (const [key, value] of Object.entries(values.defaults ?? {})) {
+      entries[key] = String(value);
+    }
+    for (const [key, byWorktree] of Object.entries(values.envs ?? {})) {
+      if (name in byWorktree)
+        entries[key] = String(byWorktree[name]);
+    }
+    if (Object.keys(entries).length === 0)
+      continue;
+    const dotenv = Bun.file(join(path, ".env"));
+    const current = await dotenv.exists() ? await dotenv.text() : "";
+    await Bun.write(dotenv, updateDotenv(current, entries));
+    ctx.log(`Pushed ${name}`);
+  }
+  return 0;
+}
+async function pull(ctx) {
+  const read = await readValues(ctx);
+  if (!read)
+    return 1;
+  const { path: valuesPath, values } = read;
+  const envs = values.envs ??= {};
+  for (const { name, path } of await listWorktrees(ctx.cwd)) {
+    const dotenv = Bun.file(join(path, ".env"));
+    if (!await dotenv.exists())
+      continue;
+    const parsed = parseDotenv(await dotenv.text());
+    for (const [key, byWorktree] of Object.entries(envs)) {
+      if (!(key in parsed))
+        delete byWorktree[name];
+    }
+    for (const [key, value] of Object.entries(parsed)) {
+      (envs[key] ??= {})[name] = value;
+    }
+    ctx.log(`Pulled ${name}`);
+  }
+  for (const [key, byWorktree] of Object.entries(envs)) {
+    if (Object.keys(byWorktree).length === 0)
+      delete envs[key];
+  }
+  await Bun.write(valuesPath, Bun.YAML.stringify(values, null, 2));
+  return 0;
+}
+async function edit(ctx) {
+  const pulled = await pull(ctx);
+  if (pulled !== 0)
+    return pulled;
+  const valuesPath = join(await findRoot(ctx.cwd), ".envs/values.yml");
+  const code = await ctx.openEditor(valuesPath);
+  if (code !== 0)
+    return code;
+  return await push(ctx);
+}
+async function run(args, ctx = defaultContext()) {
+  const [command = "help"] = args;
+  switch (command) {
+    case "help":
+    case "--help":
+    case "-h":
+      ctx.log(HELP);
+      return 0;
+    case "init":
+      return await init(ctx);
+    case "push":
+      return await push(ctx);
+    case "pull":
+      return await pull(ctx);
+    case "edit":
+      return await edit(ctx);
+    default:
+      ctx.error(`Unknown command: ${command}
+
+${HELP}`);
+      return 1;
+  }
+}
+
+// src/bin/envs.ts
+process.exit(await run(Bun.argv.slice(2)));

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@jondotsoy/envs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "module": "envs.js",
+  "type": "module",
+  "bin": {
+    "envs": "envs.js"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.