devault-cli 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# d(evault)
+
+we all work on too many projects now. why do we have to remember (and type) dev commands?
+
+one project has `bun dev`, the other `pnpm dev`, another `cargo run`, etc.
+
+what if all you needed to type was `d`?
+
+## installation
+
+requires bun.
+
+```sh
+npm i -g devault-cli
+```
+
+## usage
+
+```sh
+d
+```
+
+running `d` for the first time in a directory will ask you for the command it should run. future runs will immediately alias to the command you've entered.
+
+## commands
+
+save a command for the current directory:
+
+```sh
+d set "bun dev"
+```
+
+run it later:
+
+```sh
+d
+```
+
+see what `d` thinks this directory is:
+
+```sh
+d show
+```
+
+forget the saved command:
+
+```sh
+d forget
+```
+
+list everything you've saved:
+
+```sh
+d list
+```
+
+## examples
+
+the command can be whatever you would have typed yourself:
+
+```sh
+d set "bun dev"
+d set "pnpm dev"
+d set "npm run dev"
+d set "yarn dev"
+d set "mise run dev"
+d set "make dev"
+d set "just dev"
+d set "docker compose up"
+d set "cargo run"
+d set "go run ."
+```
+
+devault does not know what a dev server is. it just remembers the command you told it.
+
+## first run
+
+if nothing is saved yet, `d` will suggest obvious commands from the files in the project.
+
+for node projects it looks at lockfiles and package scripts, so a bun project with a `dev` script gets:
+
+```sh
+bun dev
+```
+
+for other projects it can suggest things like:
+
+```sh
+mise run dev
+make dev
+docker compose up
+cargo run
+go run .
+```
+
+you can always ignore the suggestions and type the command yourself.
+
+## non-interactive
+
+set `D_NO_PROMPT=1` if you want `d` to fail instead of asking questions:
+
+```sh
+D_NO_PROMPT=1 d
+```
+
+## development
+
+run with bun:
+
+```sh
+bun run dev
+```
+
+build:
+
+```sh
+bun run build
+```
+
+the built cli is bundled into:
+
+```txt
+dist/cli.js
+```
+
+## notes
+
+this is intentionally not a task runner, process manager, env manager, monorepo thing, shell integration, or runtime. what makes it good is it's everything-agnostic. you tell `d` what to run, and it does so.
+
+it is a glorified auto-alias with a memory.
+
+that is the whole point.

package/dist/cli.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/suggest.ts
+var exports_suggest = {};
+__export(exports_suggest, {
+  suggestCommands: () => suggestCommands,
+  directoryHasFiles: () => directoryHasFiles
+});
+import { readdir, readFile } from "fs/promises";
+import { access } from "fs/promises";
+import { join } from "path";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function suggestCommands(root) {
+  const suggestions = new Set;
+  await addNodeSuggestions(root, suggestions);
+  await addGenericSuggestions(root, suggestions);
+  return [...suggestions];
+}
+async function addNodeSuggestions(root, suggestions) {
+  const packageJsonPath = join(root, "package.json");
+  if (!await exists(packageJsonPath))
+    return;
+  const packageManager = await detectPackageManager(root);
+  const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+  for (const script of preferredScripts) {
+    if (packageJson.scripts?.[script]) {
+      suggestions.add(packageManager === "npm" ? `npm run ${script}` : `${packageManager} ${script}`);
+    }
+  }
+}
+async function detectPackageManager(root) {
+  if (await exists(join(root, "bun.lock")) || await exists(join(root, "bun.lockb")))
+    return "bun";
+  if (await exists(join(root, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (await exists(join(root, "yarn.lock")))
+    return "yarn";
+  if (await exists(join(root, "package-lock.json")))
+    return "npm";
+  return "npm";
+}
+async function addGenericSuggestions(root, suggestions) {
+  if (await hasMiseDev(root))
+    suggestions.add("mise run dev");
+  if (await hasMakeDev(root))
+    suggestions.add("make dev");
+  if (await exists(join(root, "compose.yaml")) || await exists(join(root, "docker-compose.yml"))) {
+    suggestions.add("docker compose up");
+  }
+  if (await exists(join(root, "Cargo.toml")))
+    suggestions.add("cargo run");
+  if (await exists(join(root, "go.mod")))
+    suggestions.add("go run .");
+}
+async function hasMiseDev(root) {
+  for (const file of ["mise.toml", ".mise.toml"]) {
+    const path = join(root, file);
+    if (await exists(path) && (await readFile(path, "utf8")).includes("[tasks.dev]"))
+      return true;
+  }
+  return false;
+}
+async function hasMakeDev(root) {
+  for (const file of ["Makefile", "makefile"]) {
+    const path = join(root, file);
+    if (!await exists(path))
+      continue;
+    const contents = await readFile(path, "utf8");
+    if (/^dev\s*:/m.test(contents))
+      return true;
+  }
+  return false;
+}
+async function directoryHasFiles(root) {
+  return (await readdir(root)).length > 0;
+}
+var preferredScripts;
+var init_suggest = __esm(() => {
+  preferredScripts = ["dev", "start", "serve", "watch"];
+});
+
+// src/cli.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2, resolve } from "path";
+import { spawn } from "child_process";
+import { stdin as input, stdout as output } from "process";
+var noPrompt = process.env.D_NO_PROMPT === "1";
+var cwd = resolve(process.cwd());
+var configPath = join2(homedir(), ".config", "devault", "config.json");
+var suspicious = /\b(rm|dropdb|reset|prune|destroy|delete)\b|\bmigrate\s+reset\b/;
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+  if (!cmd)
+    return runDefault();
+  if (cmd === "set")
+    return setCommand(args);
+  if (cmd === "show")
+    return showCommand();
+  if (cmd === "forget")
+    return forgetCommand();
+  if (cmd === "list")
+    return listCommands();
+  console.error("usage: d [set <command>|show|forget|list]");
+  return 1;
+}
+async function runDefault() {
+  const command = commandFor(cwd);
+  if (command) {
+    await guard(command, "run");
+    return run(cwd, command);
+  }
+  if (noPrompt) {
+    console.error(`d: no command set for ${cwd}`);
+    return 1;
+  }
+  const selected = await askForCommand(cwd);
+  if (!selected)
+    return 1;
+  await guard(selected, "save and run");
+  saveCommand(cwd, selected);
+  return run(cwd, selected);
+}
+async function setCommand(parts) {
+  const command = parts.join(" ").trim();
+  if (!command) {
+    console.error("usage: d set <command>");
+    return 1;
+  }
+  await guard(command, "save");
+  saveCommand(cwd, command);
+  console.log(`d: ${cwd} -> ${command}`);
+  return 0;
+}
+function showCommand() {
+  const command = commandFor(cwd);
+  console.log(`d: ${cwd} -> ${command ?? "none"}`);
+  return 0;
+}
+function forgetCommand() {
+  const config = readConfig();
+  const hadCommand = Object.hasOwn(config.projects, cwd);
+  delete config.projects[cwd];
+  writeConfig(config);
+  console.log(hadCommand ? `d: forgot ${cwd}` : `d: nothing saved for ${cwd}`);
+  return 0;
+}
+function listCommands() {
+  const projects = Object.values(readConfig().projects).sort((a, b) => a.root.localeCompare(b.root));
+  if (projects.length === 0) {
+    console.log("d: no saved commands");
+    return 0;
+  }
+  for (const project of projects) {
+    console.log(`${project.root} -> ${project.command}`);
+  }
+  return 0;
+}
+function commandFor(root) {
+  return readConfig().projects[root]?.command;
+}
+function readConfig() {
+  return readJson(configPath) ?? { version: 1, projects: {} };
+}
+function readJson(path) {
+  if (!existsSync(path))
+    return;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function saveCommand(root, command) {
+  const config = readConfig();
+  config.projects[root] = { command, root };
+  writeConfig(config);
+}
+function writeConfig(config) {
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+}
+async function askForCommand(root) {
+  const [{ createInterface }, { suggestCommands: suggestCommands2 }] = await Promise.all([
+    import("readline/promises"),
+    Promise.resolve().then(() => (init_suggest(), exports_suggest))
+  ]);
+  const suggestions = await suggestCommands2(root);
+  const rl = createInterface({ input, output });
+  try {
+    console.log(`d: no command set for ${root}`);
+    suggestions.forEach((command, index) => console.log(`${index + 1}. ${command}`));
+    console.log(`${suggestions.length + 1}. custom`);
+    const answer = (await rl.question("command: ")).trim();
+    const choice = Number(answer);
+    if (Number.isInteger(choice) && choice >= 1 && choice <= suggestions.length)
+      return suggestions[choice - 1];
+    if (choice === suggestions.length + 1 || answer === "") {
+      const custom = (await rl.question("custom: ")).trim();
+      return custom || undefined;
+    }
+    return answer;
+  } finally {
+    rl.close();
+  }
+}
+async function guard(command, action) {
+  if (!suspicious.test(command))
+    return;
+  if (noPrompt)
+    throw new Error(`refusing to ${action} suspicious command: ${command}`);
+  const { createInterface } = await import("readline/promises");
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question(`d: suspicious command, ${action} anyway? ${command} [y/N] `)).trim();
+    if (!/^y(es)?$/i.test(answer))
+      throw new Error("cancelled");
+  } finally {
+    rl.close();
+  }
+}
+function run(root, command) {
+  console.log(`d: ${root} -> ${command}`);
+  return new Promise((resolveCode) => {
+    const child = spawn(command, { cwd: root, shell: true, stdio: "inherit" });
+    child.on("error", (error) => {
+      console.error(`d: failed to run command: ${error.message}`);
+      resolveCode(1);
+    });
+    child.on("close", (code, signal) => {
+      if (signal) {
+        console.error(`d: command stopped by ${signal}`);
+        resolveCode(1);
+        return;
+      }
+      resolveCode(code ?? 0);
+    });
+  });
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  console.error(`d: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "devault-cli",
+  "version": "0.1.0",
+  "description": "A directory-aware default dev command launcher.",
+  "type": "module",
+  "bin": {
+    "d": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsgo --noEmit && bun build src/cli.ts --target=bun --outfile=dist/cli.js && chmod +x dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "check": "tsgo --noEmit"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260527.2",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "license": "MIT"
+}