@uplift-beyond/upex 0.0.0-stage → 1.5.0

package/src/commands/remove.js

@@ -0,0 +1,35 @@
+/**
+ * remove.js -- Delete a saved shortcut.
+ * Usage: upex remove <name>
+ */
+
+import { removeLink, loadLinks } from '../store.js';
+import { resolveName } from '../fuzzy.js';
+import * as ui from '../ui.js';
+
+export function registerRemove(program) {
+  program
+    .command('remove <name>')
+    .alias('rm')
+    .description('Remove a saved shortcut')
+    .action((name) => {
+      const links = loadLinks();
+      const resolved = resolveName(name, links);
+
+      if (!resolved) {
+        ui.error(`Shortcut not found: ${name}`);
+        return;
+      }
+
+      if (!resolved.exact) {
+        ui.warn(`No exact match. Did you mean "${resolved.name}"?`);
+        ui.info(`Run: upex remove ${resolved.name}`);
+        return;
+      }
+
+      const entry = links[name];
+      removeLink(name);
+      ui.success(`Removed: ${name} --> ${entry.path || entry.app || entry.url}`);
+    });
+}
+

package/src/commands/rename.js

@@ -0,0 +1,47 @@
+ /**
+ * rename.js -- Rename a shortcut key
+ * Usage: upex rename <oldName> <newName>
+ */
+
+import { renameLink, loadLinks, nameError } from '../store.js';
+import { resolveName } from '../fuzzy.js';
+import * as ui from '../ui.js';
+
+export function registerRename(program) {
+  program
+    .command('rename <oldName> <newName>')
+    .description('Rename a shortcut')
+    .action((oldName, newName) => {
+      const links = loadLinks();
+      const resolved = resolveName(oldName, links);
+
+      if (!resolved) {
+        ui.error(`Shortcut not found: ${oldName}`);
+        return;
+      }
+
+      if (!resolved.exact) {
+        ui.warn(`No exact match. Did you mean "${resolved.name}"?`);
+        ui.info(`Run: upex rename ${resolved.name} ${newName}`);
+        return;
+      }
+
+      const bad = nameError(newName);
+      if (bad) {
+        ui.error(bad);
+        return;
+      }
+
+      const result = renameLink(oldName, newName);
+      if (!result.ok) {
+        if (result.reason === 'exists') {
+          ui.error(`"${newName}" already exists. Remove it first or pick a different name.`);
+        } else {
+          ui.error(`Shortcut not found: ${oldName}`);
+        }
+        return;
+      }
+
+      ui.success(`Renamed: ${oldName} --> ${newName}`);
+    });
+}

package/src/commands/run.js

@@ -0,0 +1,84 @@
+/**
+ * run.js -- Run a package.json script in a terminal at a shortcut's folder.
+ * Usage: upex run <name> [script]
+ *   upex run velora          -- list available scripts
+ *   upex run velora dev      -- open a terminal running "<pm> run dev" at velora
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { loadLinks } from '../store.js';
+import { resolveName } from '../fuzzy.js';
+import { handleOpen } from './open.js';
+import * as ui from '../ui.js';
+
+// Pick a package manager from the lockfile present in the folder (npm default).
+function detectPm(dir) {
+  if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(dir, 'yarn.lock'))) return 'yarn';
+  if (fs.existsSync(path.join(dir, 'bun.lockb')) || fs.existsSync(path.join(dir, 'bun.lock'))) return 'bun';
+  return 'npm';
+}
+
+function readScripts(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+    return pkg.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : {};
+  } catch {
+    return null;
+  }
+}
+
+export function registerRun(program) {
+  program
+    .command('run <name> [script]')
+    .description('Run a package.json script in a terminal at the shortcut folder')
+    .summary('Run a package.json script in a terminal')
+    .action((name, script) => {
+      const links = loadLinks();
+      const resolved = resolveName(name, links);
+      if (!resolved) {
+        ui.error(`Shortcut not found: ${name}`);
+        process.exit(1);
+      }
+
+      const dir = links[resolved.name].path;
+      if (!dir || !fs.existsSync(dir)) {
+        ui.error(`No valid folder for "${resolved.name}".`);
+        process.exit(1);
+      }
+
+      const scripts = readScripts(dir);
+      if (!scripts) {
+        ui.error(`No package.json in ${dir}`);
+        process.exit(1);
+      }
+
+      const pm = detectPm(dir);
+
+      // No script given: list what's available.
+      if (!script) {
+        const names = Object.keys(scripts);
+        if (!names.length) {
+          ui.info('No scripts defined in package.json.');
+          return;
+        }
+        ui.heading(`Scripts (${pm}) -- ${resolved.name}`);
+        ui.table(
+          [[chalk.bold('SCRIPT'), chalk.bold('COMMAND')], ...names.map(n => [chalk.cyan(n), chalk.dim(scripts[n])])],
+          { header: true },
+        );
+        ui.blank();
+        ui.dim(`Run one: upex run ${resolved.name} <script>`);
+        return;
+      }
+
+      if (!Object.hasOwn(scripts, script)) {
+        ui.error(`No "${script}" script in ${resolved.name}. Available: ${Object.keys(scripts).join(', ') || '(none)'}`);
+        process.exit(1);
+      }
+
+      return handleOpen(resolved.name, 'cmd', 1, `${pm} run ${script}`);
+    });
+}

package/src/commands/setup.js

@@ -0,0 +1,178 @@
+/**
+ * setup.js -- Show shell integration instructions.
+ * Usage: upex setup
+ */
+
+import chalk from 'chalk';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import * as ui from '../ui.js';
+
+const BASH_ZSH_FUNCTION = `# ~/.bashrc or ~/.zshrc
+upex() {
+  if [ "$1" = "go" ] && [ -n "$2" ]; then
+    if result=$(command upex go "$2" 2>/dev/null) && cd "$result"; then
+      shift 2
+      [ $# -eq 0 ] || "$@"
+      return
+    fi
+  fi
+  if [ "$1" != "" ] && [ "$2" = "" ] && result=$(command upex __resolve "$1" 2>/dev/null); then
+    cd "$result"
+  else
+    command upex "$@"
+  fi
+}`;
+
+const POWERSHELL_FUNCTION = `# PowerShell profile ($PROFILE)
+function upex {
+  if ($args.Count -ge 2 -and $args[0] -eq 'go') {
+    $result = & upex.ps1 go $args[1] 2>$null
+    if ($LASTEXITCODE -eq 0 -and $result) {
+      Set-Location $result
+      $rest = @($args | Select-Object -Skip 2)
+      if ($rest.Count) { Invoke-Expression ($rest -join ' ') }
+      return
+    }
+  }
+  if ($args.Count -eq 1) {
+    $result = & upex.ps1 __resolve $args[0] 2>$null
+    if ($LASTEXITCODE -eq 0 -and $result) {
+      Set-Location $result
+      return
+    }
+  }
+  & upex.ps1 @args
+}`;
+
+const FISH_FUNCTION = `# ~/.config/fish/functions/upex.fish
+function upex
+  if test (count $argv) -ge 2; and test "$argv[1]" = "go"
+    set result (command upex go $argv[2] 2>/dev/null)
+    if test $status -eq 0; and test -n "$result"
+      cd $result
+      if test (count $argv) -gt 2
+        $argv[3..-1]
+      end
+      return
+    end
+  end
+  if test (count $argv) -eq 1
+    set result (command upex __resolve $argv[1] 2>/dev/null)
+    if test $status -eq 0; and test -n "$result"
+      cd $result
+      return
+    end
+  end
+  command upex $argv
+end`;
+
+// cmd.exe has no profile functions. Instead, an upex.bat placed next to the
+// npm upex.cmd shim wins PATH resolution (.bat before .cmd in PATHEXT), and a
+// cd inside a batch file persists in the parent shell.
+export const CMD_WRAPPER = [
+  '@echo off',
+  'rem upex cmd.exe wrapper (installed by "upex setup cmd").',
+  'if /i "%~1"=="go" if not "%~2"=="" goto :go',
+  'if not "%~1"=="" if "%~2"=="" goto :single',
+  'goto :pass',
+  '',
+  ':go',
+  'for /f "usebackq delims=" %%D in (`call "%~dp0upex.cmd" go "%~2" 2^>nul`) do cd /d "%%D" & goto :gorun',
+  'call "%~dp0upex.cmd" go "%~2"',
+  'exit /b',
+  '',
+  ':gorun',
+  'rem any args after the name run as a command here (upex go vel npm run dev)',
+  'shift',
+  'shift',
+  'if "%~1"=="" exit /b',
+  'set "UPEX_RUN=%1"',
+  ':gocollect',
+  'shift',
+  'if not "%~1"=="" set "UPEX_RUN=%UPEX_RUN% %1" & goto :gocollect',
+  'call %UPEX_RUN%',
+  'set "UPEX_RUN="',
+  'exit /b',
+  '',
+  ':single',
+  'for /f "usebackq delims=" %%D in (`call "%~dp0upex.cmd" __resolve "%~1" 2^>nul`) do cd /d "%%D" & exit /b',
+  ':pass',
+  'call "%~dp0upex.cmd" %*',
+  '',
+].join('\r\n');
+
+export function installCmdWrapper(dir) {
+  const target = path.join(dir, 'upex.bat');
+  fs.writeFileSync(target, CMD_WRAPPER);
+  return target;
+}
+
+export function findShimDir() {
+  try {
+    const out = execSync('where upex.cmd', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+    const first = out.split(/\r?\n/).map(s => s.trim()).find(Boolean);
+    return first ? path.dirname(first) : null;
+  } catch {
+    return null;
+  }
+}
+
+export function registerSetup(program) {
+  program
+    .command('setup [shell]')
+    .description('Shell integration for cd support ("setup cmd" installs the cmd.exe wrapper)')
+    .summary('Shell integration ("setup cmd": cmd.exe wrapper)')
+    .action((shell) => {
+      const platform = os.platform();
+
+      if (shell === 'cmd') {
+        if (platform !== 'win32') {
+          ui.error('The cmd.exe wrapper is Windows-only.');
+          process.exit(1);
+        }
+        const shimDir = findShimDir();
+        if (!shimDir) {
+          ui.error('upex.cmd not found on PATH. Install upex globally first (npm i -g upex).');
+          process.exit(1);
+        }
+        const target = installCmdWrapper(shimDir);
+        ui.success(`Installed ${target}`);
+        ui.dim('"upex go <name>" and "upex <name>" now cd in cmd.exe (current session too).');
+        return;
+      }
+
+      ui.heading('Shell Integration');
+
+      ui.dim('A wrapper function is required for cd behavior.');
+      ui.dim('Node.js cannot change the parent shell directory directly.');
+      ui.blank();
+
+      if (platform === 'win32') {
+        console.log(chalk.bold('  Command Prompt (cmd.exe):'));
+        ui.separator(40);
+        ui.info('run: upex setup cmd');
+        ui.dim('installs an upex.bat wrapper next to the npm shim, no profile needed');
+        ui.blank();
+        console.log(chalk.bold('  PowerShell:'));
+        ui.separator(40);
+        console.log(POWERSHELL_FUNCTION.split('\n').map(l => '    ' + l).join('\n'));
+      } else {
+        console.log(chalk.bold('  Bash / Zsh:'));
+        ui.separator(40);
+        console.log(BASH_ZSH_FUNCTION.split('\n').map(l => '    ' + l).join('\n'));
+      }
+
+      ui.blank();
+      console.log(chalk.bold('  Fish:'));
+      ui.separator(40);
+      console.log(FISH_FUNCTION.split('\n').map(l => '    ' + l).join('\n'));
+
+      ui.blank();
+      ui.separator();
+      ui.dim('Restart your shell after adding the function.');
+      ui.blank();
+    });
+}

package/src/commands/tag.js

@@ -0,0 +1,101 @@
+/**
+ * tag.js -- Manage tags on shortcuts and open a whole tag group.
+ * Usage: upex tag                    -- list all tags with counts
+ *        upex tag <name>             -- show a shortcut's tags
+ *        upex tag <name> <tags...>   -- add tags
+ *        upex tag <name> -r <tags..> -- remove tags (or --clear to drop all)
+ *        upex open <tag>             -- open every shortcut carrying <tag>
+ */
+
+import chalk from 'chalk';
+import { loadLinks, setLink } from '../store.js';
+import { resolveName } from '../fuzzy.js';
+import { handleOpen } from './open.js';
+import * as ui from '../ui.js';
+
+function allTags(links) {
+  const counts = {};
+  for (const entry of Object.values(links)) {
+    for (const t of entry.tags || []) counts[t] = (counts[t] || 0) + 1;
+  }
+  return counts;
+}
+
+export function registerTag(program) {
+  program
+    .command('tag [name] [tags...]')
+    .description('List tags, or add/remove tags on a shortcut')
+    .option('-r, --remove', 'Remove the listed tags instead of adding')
+    .option('--clear', 'Remove all tags from the shortcut')
+    .action((name, tags, options) => {
+      const links = loadLinks();
+
+      // No name: list every tag with a count.
+      if (!name) {
+        const counts = allTags(links);
+        const entries = Object.entries(counts);
+        if (!entries.length) {
+          ui.info('No tags yet. Add some: upex tag <name> <tag>');
+          return;
+        }
+        ui.heading('Tags');
+        ui.table(
+          [[chalk.bold('TAG'), chalk.bold('COUNT')], ...entries.map(([t, c]) => [chalk.cyan(t), String(c)])],
+          { header: true },
+        );
+        ui.blank();
+        return;
+      }
+
+      const resolved = resolveName(name, links);
+      if (!resolved) {
+        ui.error(`Shortcut not found: ${name}`);
+        process.exit(1);
+      }
+      const entry = links[resolved.name];
+      const current = entry.tags || [];
+
+      // Show tags when none are supplied and no mutation flag is set.
+      if (!options.clear && tags.length === 0) {
+        ui.info(current.length ? `${resolved.name}: ${current.join(', ')}` : `${resolved.name} has no tags.`);
+        return;
+      }
+
+      let next;
+      if (options.clear) {
+        next = [];
+      } else if (options.remove) {
+        next = current.filter(t => !tags.includes(t));
+      } else {
+        next = [...new Set([...current, ...tags])];
+      }
+
+      const updated = { ...entry };
+      if (next.length) updated.tags = next; else delete updated.tags;
+      setLink(resolved.name, updated);
+      ui.success(`${resolved.name}: ${next.length ? next.join(', ') : '(no tags)'}`);
+    });
+}
+
+export function registerOpenGroup(program) {
+  program
+    .command('open <tag>')
+    .description('Open every shortcut carrying <tag> in its default opener')
+    .summary('Open every shortcut tagged <tag>')
+    .action(async (tag) => {
+      const links = loadLinks();
+      const matches = Object.keys(links).filter(n => (links[n].tags || []).includes(tag));
+
+      if (!matches.length) {
+        ui.warn(`No shortcuts tagged "${tag}".`);
+        const tags = Object.keys(allTags(links));
+        if (tags.length) ui.dim(`Available tags: ${tags.join(', ')}`);
+        process.exit(1);
+      }
+
+      ui.dim(`Opening ${matches.length} shortcut${matches.length === 1 ? '' : 's'} tagged #${tag}: ${matches.join(', ')}`);
+      for (const shortcut of matches) {
+        await handleOpen(shortcut, undefined, 1, '', { batch: true });
+      }
+    });
+}

package/src/commands/transfer.js

@@ -0,0 +1,75 @@
+/**
+ * transfer.js -- Export/import shortcuts (and config) for backup or sync.
+ * Usage: upex export [file]        -- write a JSON bundle (stdout if no file)
+ *        upex import <file>        -- merge a bundle into the store
+ *        upex import <file> --replace  -- replace the store entirely
+ */
+
+import fs from 'node:fs';
+import {
+  loadLinks, saveLinks, loadConfig, saveConfig, mergeLinks,
+} from '../store.js';
+import * as ui from '../ui.js';
+
+export function registerExport(program) {
+  program
+    .command('export [file]')
+    .description('Export shortcuts + config as a JSON bundle (stdout if no file)')
+    .summary('Export shortcuts + config as JSON')
+    .action((file) => {
+      const bundle = { upex: 'bundle', version: 1, links: loadLinks(), config: loadConfig() };
+      const json = JSON.stringify(bundle, null, 2);
+      if (!file) {
+        process.stdout.write(json + '\n');
+        return;
+      }
+      fs.writeFileSync(file, json, 'utf-8');
+      ui.success(`Exported ${Object.keys(bundle.links).length} shortcuts --> ${file}`);
+    });
+}
+
+export function registerImport(program) {
+  program
+    .command('import <file>')
+    .description('Import a bundle (merge by default, --replace to overwrite)')
+    .summary('Import a bundle (merge, or --replace)')
+    .option('--replace', 'Replace all existing shortcuts instead of merging')
+    .action((file, options) => {
+      let bundle;
+      try {
+        bundle = JSON.parse(fs.readFileSync(file, 'utf-8'));
+      } catch (err) {
+        ui.error(`Cannot read ${file}: ${err.message}`);
+        process.exit(1);
+      }
+
+      // Accept a full bundle or a bare links map.
+      const incoming = bundle.links && typeof bundle.links === 'object' ? bundle.links : bundle;
+      if (!incoming || typeof incoming !== 'object') {
+        ui.error('Nothing importable in that file.');
+        process.exit(1);
+      }
+
+      const hasConfig = bundle.config && typeof bundle.config === 'object';
+      // Read config before saving links, so a corrupt config.json aborts without a partial import.
+      const current = hasConfig ? loadConfig() : null;
+      const { merged, added, updated } = mergeLinks(loadLinks(), incoming, { replace: options.replace });
+      saveLinks(merged);
+
+      // Merge config (apps + workspaces) without clobbering unless replacing.
+      if (hasConfig) {
+        const inc = bundle.config;
+        const next = options.replace ? inc : {
+          ...current,
+          ...inc,
+          apps: { ...(current.apps || {}), ...(inc.apps || {}) },
+          workspaces: { ...(current.workspaces || {}), ...(inc.workspaces || {}) },
+        };
+        saveConfig(next);
+      }
+
+      ui.success(`Imported: ${added.length} added, ${updated.length} updated.`);
+      if (added.length) ui.dim(`Added: ${added.join(', ')}`);
+      if (updated.length) ui.dim(`Updated: ${updated.join(', ')}`);
+    });
+}