@noorslvt/shev 0.0.0-stage → 0.2.1

package/bin/shev.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../scripts/launch.cjs')('shev');

package/install.sh

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# shev installer — https://github.com/aditauqir/shev
+#
+#   curl -fsSL https://raw.githubusercontent.com/aditauqir/shev/main/install.sh | bash
+#
+# Installs the `shev` (TUI) and `shev-cli` (pipe) binaries. Prefers a prebuilt
+# release for this platform; otherwise builds from source with cargo.
+set -euo pipefail
+
+REPO="aditauqir/shev"
+VERSION="0.2.1"
+if [ -n "${SHEV_PREFIX:-}" ]; then
+  PREFIX="$SHEV_PREFIX"
+elif [[ ":$PATH:" == *":$HOME/.local/bin:"* ]]; then
+  PREFIX="$HOME/.local"
+elif [[ ":$PATH:" == *":$HOME/.cargo/bin:"* ]]; then
+  PREFIX="$HOME/.cargo"
+else
+  PREFIX="$HOME/.local"
+fi
+DEST="$PREFIX/bin"
+
+say() { printf '%s\n' "$*"; }
+die() { printf 'error: %s\n' "$*" >&2; exit 1; }
+
+need() { command -v "$1" >/dev/null 2>&1; }
+
+finish() {
+  "$DEST/shev" --register-install "$DEST"
+  say ""
+  say "shev is installed in $DEST"
+  if [ "${SHEV_NO_PATH_SETUP:-0}" = 1 ]; then return; fi
+  case ":$PATH:" in
+    *":$DEST:"*) : ;;
+    *)
+      local profiles=() quoted block profile created existing login_profile shell_name="${SHELL:-sh}"
+      printf -v quoted '%q' "$DEST"
+      printf -v block '# >>> shev PATH >>>\nexport PATH=%s:$PATH\n# <<< shev PATH <<<\n' "$quoted"
+      case "${shell_name##*/}" in
+        zsh) profiles=("${ZDOTDIR:-$HOME}/.zshrc") ;;
+        bash)
+          login_profile="$HOME/.bash_profile"
+          if [ ! -f "$login_profile" ]; then
+            if [ -f "$HOME/.bash_login" ]; then login_profile="$HOME/.bash_login"
+            elif [ -f "$HOME/.profile" ]; then login_profile="$HOME/.profile"; fi
+          fi
+          profiles=("$HOME/.bashrc" "$login_profile")
+          ;;
+        fish)
+          profiles=("${XDG_CONFIG_HOME:-$HOME/.config}/fish/conf.d/shev.fish")
+          printf -v block '# >>> shev PATH >>>\nfish_add_path --prepend %s\n# <<< shev PATH <<<\n' "$quoted"
+          ;;
+        *) profiles=("$HOME/.profile") ;;
+      esac
+      for profile in "${profiles[@]}"; do
+        mkdir -p "$(dirname "$profile")"
+        existing="$(cat "$profile" 2>/dev/null || true)"
+        if [[ "$existing" != *"${block%$'\n'}"* ]]; then
+          created=0
+          [ -e "$profile" ] || created=1
+          printf '\n%s' "$block" >> "$profile"
+          SHEV_PATH_PROFILE="$profile" SHEV_PATH_BLOCK="$block" SHEV_PATH_PROFILE_CREATED="$created" "$DEST/shev" --register-install "$DEST"
+        fi
+      done
+      say "PATH is configured. Open a new terminal, then type shev."
+      ;;
+  esac
+  say ""
+  say "Run it with:"
+  say "  shev"
+}
+
+os="$(uname -s)"
+arch="$(uname -m)"
+case "$os-$arch" in
+  Darwin-arm64) target="aarch64-apple-darwin" ;;
+  Darwin-x86_64) target="x86_64-apple-darwin" ;;
+  Linux-x86_64) target="x86_64-unknown-linux-gnu" ;;
+  Linux-aarch64) target="aarch64-unknown-linux-gnu" ;;
+  *) target="" ;;
+esac
+
+mkdir -p "$DEST"
+
+# --- 1. prebuilt release, if there is one for this platform ----------------
+if [ -n "$target" ] && need curl && need tar; then
+  url="https://github.com/$REPO/releases/download/v$VERSION/shev-$target.tar.gz"
+  tmp="$(mktemp -d)"
+  trap 'rm -rf "$tmp"' EXIT
+  if curl -fsSL "$url" -o "$tmp/shev.tar.gz" 2>/dev/null && tar -xzf "$tmp/shev.tar.gz" -C "$tmp"; then
+    [ -f "$tmp/shev" ] || die "the downloaded archive had no shev binary"
+    if [ "$("$tmp/shev" --version 2>/dev/null)" = "shev $VERSION" ]; then
+    install -m 0755 "$tmp/shev" "$DEST/shev"
+    if [ -f "$tmp/shev-cli" ]; then
+      install -m 0755 "$tmp/shev-cli" "$DEST/shev-cli"
+    fi
+    finish
+    exit 0
+    fi
+  fi
+  rm -rf "$tmp"
+  trap - EXIT
+fi
+
+# --- 2. build from source ---------------------------------------------------
+if ! need cargo; then
+  need curl || die "no cargo and no curl — install Rust from https://rustup.rs first"
+  say "No cargo found. Installing Rust (rustup, minimal profile)…"
+  curl -fsSL https://sh.rustup.rs | sh -s -- -y --profile minimal
+  # shellcheck disable=SC1091
+  . "$HOME/.cargo/env"
+fi
+
+say "Building shev from source with cargo (this takes a minute)…"
+if [ -n "${SHEV_SOURCE_DIR:-}" ]; then
+  cargo install --path "$SHEV_SOURCE_DIR" --locked --force --root "$PREFIX"
+else
+  cargo install --git "https://github.com/$REPO" --locked --force --root "$PREFIX"
+fi
+
+[ -x "$DEST/shev" ] || die "cargo finished but $DEST/shev is missing"
+finish

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@noorslvt/shev",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "A simple Jev-like decision making tool, without the hype.",
+  "license": "Apache-2.0",
+  "repository": { "type": "git", "url": "https://github.com/aditauqir/shev.git" },
+  "engines": { "node": ">=18" },
+  "bin": { "shev": "bin/shev.cjs", "shev-cli": "bin/shev-cli.cjs" },
+  "scripts": { "postinstall": "node scripts/install.cjs", "test": "node --test scripts/*.test.cjs" },
+  "files": ["bin", "scripts", "src", "assets", "Cargo.toml", "Cargo.lock", "install.sh", "README.md", "LICENSE"]
+}

package/scripts/install.cjs

@@ -0,0 +1,28 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { randomUUID } = require('node:crypto');
+
+const root = path.resolve(__dirname, '..');
+const state = path.join(root, '.install-state');
+const installId = randomUUID();
+fs.writeFileSync(path.join(root, '.shev-install-id'), installId);
+if (process.platform === 'win32') {
+  console.error('shev currently supports macOS/Linux terminals; on Windows use WSL.');
+  process.exit(1);
+}
+fs.mkdirSync(state, { recursive: true });
+fs.writeFileSync(path.join(state, '.shev-owned'), 'shev managed state\n');
+const result = spawnSync('bash', [path.join(root, 'install.sh')], {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    SHEV_PREFIX: path.join(root, 'native'),
+    SHEV_SOURCE_DIR: root,
+    SHEV_HOME: state,
+    SHEV_NO_PATH_SETUP: '1',
+    SHEV_INSTALL_ID: installId,
+  },
+});
+if (result.error) console.error(`Could not install shev: ${result.error.message}`);
+process.exit(result.status ?? 1);

package/scripts/launch.cjs

@@ -0,0 +1,64 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const os = require('node:os');
+const packageName = require('../package.json').name;
+
+module.exports = function launch(binary) {
+  const root = path.resolve(__dirname, '..');
+  const native = path.join(root, 'native', 'bin', binary);
+  if (!fs.existsSync(native)) {
+    console.error(`shev's native binary is missing. Run npm rebuild -g ${packageName} --foreground-scripts.`);
+    process.exit(1);
+  }
+  const args = process.argv.slice(2);
+  const state = path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), '.local', 'share'), 'shev-npm', 'state');
+  const marker = path.join(state, '.shev-owned');
+  try {
+    if (!fs.existsSync(state)) {
+      fs.mkdirSync(state, { recursive: true, mode: 0o700 });
+      fs.writeFileSync(marker, 'shev managed state\n', { flag: 'wx', mode: 0o600 });
+    }
+    if (fs.readFileSync(marker, 'utf8') !== 'shev managed state\n') throw new Error('unrecognized state directory');
+    const installId = fs.readFileSync(path.join(root, '.shev-install-id'), 'utf8');
+    const manifestPath = path.join(state, 'config', 'install.json');
+    const manifest = fs.existsSync(manifestPath) ? JSON.parse(fs.readFileSync(manifestPath, 'utf8')) : {};
+    if (manifest.installation_id !== installId) {
+      const registration = spawnSync(native, ['--register-install', path.dirname(native)], {
+        encoding: 'utf8', env: { ...process.env, SHEV_HOME: state, SHEV_INSTALL_ID: installId },
+      });
+      if (registration.status !== 0) throw new Error(registration.stderr || 'could not register installation ownership');
+    }
+  } catch (error) {
+    console.error(`Could not initialize shev safely: ${error.message}`);
+    process.exit(1);
+  }
+  const result = spawnSync(native, args, {
+    stdio: 'inherit',
+    env: { ...process.env, SHEV_HOME: state },
+  });
+  if (result.error) console.error(result.error.message);
+  if (result.status !== 0 || args[0] !== '--uninstall' || args.includes('--dry-run')) {
+    process.exit(result.status ?? 1);
+  }
+  // npm >=7 intentionally does not run uninstall lifecycle hooks. The explicit
+  // native uninstaller cleans external registrations first; only then remove npm.
+  const npmRoot = spawnSync('npm', ['root', '--global'], { encoding: 'utf8' });
+  const sameRoot = (candidate) => {
+    try { return fs.realpathSync(candidate) === fs.realpathSync(root); } catch { return false; }
+  };
+  let uninstallArgs;
+  if (npmRoot.status === 0 && sameRoot(path.join(npmRoot.stdout.trim(), packageName))) {
+    uninstallArgs = ['uninstall', '--global', packageName];
+  } else {
+    const modules = path.dirname(path.dirname(root));
+    if (path.basename(modules) === 'node_modules') {
+      uninstallArgs = ['uninstall', '--prefix', path.dirname(modules), packageName];
+    }
+  }
+  if (uninstallArgs) {
+    const removal = spawnSync('npm', uninstallArgs, { stdio: 'inherit' });
+    process.exit(removal.status ?? 1);
+  }
+  console.log('Native shev installation removed. Source checkout kept.');
+};

package/scripts/launch.test.cjs

@@ -0,0 +1,56 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+function fixture() {
+  const home = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'shev-npm-test-')));
+  const root = path.join(home, 'global', 'lib', 'node_modules', '@noorslvt', 'shev');
+  for (const name of ['scripts', 'bin', 'native/bin']) fs.mkdirSync(path.join(root, name), { recursive: true });
+  for (const name of ['scripts/launch.cjs', 'bin/shev.cjs', 'bin/shev-cli.cjs', 'package.json']) {
+    fs.copyFileSync(path.join(__dirname, '..', name), path.join(root, name));
+  }
+  fs.writeFileSync(path.join(root, '.shev-install-id'), 'fixture-install');
+  const native = `#!${process.execPath}\nconst fs=require('node:fs'),path=require('node:path');if(process.argv[2]==='--register-install'){const dir=path.join(process.env.SHEV_HOME,'config');fs.mkdirSync(dir,{recursive:true});fs.writeFileSync(path.join(dir,'install.json'),JSON.stringify({installation_id:process.env.SHEV_INSTALL_ID}));process.exit(0);}console.log(JSON.stringify({args:process.argv.slice(2),home:process.env.SHEV_HOME})); process.exit(Number(process.env.FIXTURE_EXIT||0));\n`;
+  for (const name of ['shev', 'shev-cli']) fs.writeFileSync(path.join(root, 'native/bin', name), native, { mode: 0o755 });
+  const mockBin = path.join(home, 'mock-bin'); fs.mkdirSync(mockBin);
+  const npmLog = path.join(home, 'npm-log.json');
+  fs.writeFileSync(path.join(mockBin, 'npm'), `#!${process.execPath}\nconst fs=require('node:fs');const args=process.argv.slice(2);if(args[0]==='root')console.log(${JSON.stringify(path.join(home,'global/lib/node_modules'))});else fs.writeFileSync(${JSON.stringify(npmLog)},JSON.stringify(args));\n`, { mode: 0o755 });
+  const env = { ...process.env, HOME: home, PATH: mockBin + path.delimiter + process.env.PATH };
+  return { home, root, env, npmLog };
+}
+
+test('npm exposes shev and shev-cli, forwarding arguments and isolating its state', () => {
+  const f = fixture();
+  try {
+    for (const name of ['shev', 'shev-cli']) {
+      const result = spawnSync(process.execPath, [path.join(f.root, 'bin', `${name}.cjs`), '--file', 'a file.json'], { env: f.env, encoding: 'utf8' });
+      assert.equal(result.status, 0, result.stderr);
+      const output = JSON.parse(result.stdout);
+      assert.deepEqual(output.args, ['--file', 'a file.json']);
+      assert.equal(output.home, path.join(f.home, '.local/share/shev-npm/state'));
+    }
+  } finally { fs.rmSync(f.home, { recursive: true }); }
+});
+
+test('dry-run and cancelled removal never invoke npm uninstall', () => {
+  const f = fixture();
+  try {
+    const wrapper = path.join(f.root, 'bin/shev.cjs');
+    let result = spawnSync(process.execPath, [wrapper, '--uninstall', '--dry-run'], { env: f.env });
+    assert.equal(result.status, 0); assert.equal(fs.existsSync(f.npmLog), false);
+    result = spawnSync(process.execPath, [wrapper, '--uninstall'], { env: { ...f.env, FIXTURE_EXIT: '2' } });
+    assert.equal(result.status, 2); assert.equal(fs.existsSync(f.npmLog), false);
+  } finally { fs.rmSync(f.home, { recursive: true }); }
+});
+
+test('full confirmed removal invokes npm only for the package owning this wrapper', () => {
+  const f = fixture();
+  try {
+    const result = spawnSync(process.execPath, [path.join(f.root, 'bin/shev.cjs'), '--uninstall', '--yes'], { env: f.env });
+    assert.equal(result.status, 0);
+    assert.deepEqual(JSON.parse(fs.readFileSync(f.npmLog)), ['uninstall', '--global', '@noorslvt/shev']);
+  } finally { fs.rmSync(f.home, { recursive: true }); }
+});