itsvertical 0.0.5 → 0.0.6

package/README.md

@@ -51,6 +51,7 @@ All entities are addressed by ID. Use `itsvertical show` to see IDs. Every comma
 ### Project
 
 ```
+itsvertical <file>                              # Shorthand for "open"
 itsvertical new <path> <name>                   # Create a new .vertical file
 itsvertical open <file>                         # Open in the browser UI
 itsvertical show <file>                         # Print the board to the terminal
@@ -96,7 +97,7 @@ itsvertical layer status <file> <layer-id> none # Clear status
 
 ### Browser UI
 
-`itsvertical open` starts a local server and opens the board in your browser. Click **Save** or press **Ctrl+S** / **Cmd+S** to write changes back to the file.
+`itsvertical open` (or just `itsvertical <file>`) starts a local server and opens the board in your browser. Changes are saved automatically.
 
 ## The board
 
@@ -121,7 +122,6 @@ Each box represents a vertical slice of work.
 | **Delete** / **Backspace** | Delete focused task or unsplit focused layer |
 | **Enter** | Save inline edit |
 | **Shift+Enter** | Save edit and create a new task below |
-| **Ctrl/Cmd+S** | Save to file |
 
 ## The `.vertical` file
 

package/cli/dist/index.js

@@ -1472,8 +1472,8 @@ var require_react = __commonJS({
 });
 
 // cli/index.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import { dirname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
@@ -2255,6 +2255,283 @@ async function startServer(filePath, options = {}) {
   });
 }
 
+// cli/update.ts
+import { execFile } from "child_process";
+import fs3 from "fs";
+import os from "os";
+import path3 from "path";
+var CACHE_DIR = path3.join(os.homedir(), ".itsvertical");
+var CACHE_FILE = path3.join(CACHE_DIR, "update-check.json");
+var CHECK_INTERVAL = 864e5;
+var FETCH_TIMEOUT = 5e3;
+var REGISTRY_URL = "https://registry.npmjs.org/itsvertical/latest";
+function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na > nb)
+      return 1;
+    if (na < nb)
+      return -1;
+  }
+  return 0;
+}
+function isPathInside(childPath, parentPath) {
+  const relative = path3.relative(parentPath, childPath);
+  return relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
+}
+function resolveScriptPath(scriptPath) {
+  try {
+    return fs3.realpathSync(scriptPath);
+  } catch {
+    return scriptPath;
+  }
+}
+function getNpmGlobalPackages() {
+  const isWindows = process.platform === "win32";
+  const envKey = Object.keys(process.env).find(
+    (k) => k.toLowerCase() === "npm_config_prefix"
+  );
+  const envValue = envKey ? process.env[envKey] : void 0;
+  if (envValue) {
+    const prefix2 = path3.resolve(envValue);
+    return path3.join(prefix2, isWindows ? "node_modules" : "lib/node_modules");
+  }
+  let prefix;
+  if (isWindows) {
+    prefix = process.env.APPDATA ? path3.join(process.env.APPDATA, "npm") : path3.dirname(process.execPath);
+  } else if (process.execPath.includes("/Cellar/node")) {
+    prefix = process.execPath.slice(0, process.execPath.indexOf("/Cellar/node"));
+  } else {
+    prefix = path3.dirname(path3.dirname(process.execPath));
+  }
+  return path3.join(prefix, isWindows ? "node_modules" : "lib/node_modules");
+}
+function getPnpmGlobalDir() {
+  if (process.env.PNPM_HOME)
+    return process.env.PNPM_HOME;
+  if (process.env.XDG_DATA_HOME)
+    return path3.join(process.env.XDG_DATA_HOME, "pnpm");
+  if (process.platform === "darwin")
+    return path3.join(os.homedir(), "Library/pnpm");
+  if (process.platform !== "win32")
+    return path3.join(os.homedir(), ".local/share/pnpm");
+  if (process.env.LOCALAPPDATA)
+    return path3.join(process.env.LOCALAPPDATA, "pnpm");
+  return path3.join(os.homedir(), ".pnpm");
+}
+function getYarnGlobalPackages() {
+  const isWindows = process.platform === "win32";
+  let dataDir;
+  if (isWindows) {
+    dataDir = process.env.LOCALAPPDATA ? path3.join(process.env.LOCALAPPDATA, "Yarn/Data") : path3.join(os.homedir(), ".config/yarn");
+  } else if (process.env.XDG_DATA_HOME) {
+    dataDir = path3.join(process.env.XDG_DATA_HOME, "yarn");
+  } else {
+    dataDir = path3.join(os.homedir(), ".config/yarn");
+  }
+  return path3.join(dataDir, "global/node_modules");
+}
+function getBunGlobalDir() {
+  return process.env.BUN_INSTALL || path3.join(os.homedir(), ".bun");
+}
+function detectInstallContext(scriptPath) {
+  const resolved = resolveScriptPath(scriptPath);
+  const npxMatch = resolved.match(/(.+\/_npx\/[^/]+)/);
+  if (npxMatch) {
+    return { type: "npx-cache", cachePath: npxMatch[1] };
+  }
+  const bunDir = path3.resolve(getBunGlobalDir());
+  if (isPathInside(resolved, bunDir)) {
+    const bunCacheDir = path3.join(bunDir, "install", "cache");
+    if (isPathInside(resolved, bunCacheDir)) {
+      return { type: "bunx-cache", cacheDir: bunCacheDir };
+    }
+    return { type: "global", packageManager: "bun" };
+  }
+  const pnpmDir = path3.resolve(getPnpmGlobalDir());
+  if (isPathInside(resolved, pnpmDir)) {
+    return { type: "global", packageManager: "pnpm" };
+  }
+  const yarnPackages = path3.resolve(getYarnGlobalPackages());
+  if (isPathInside(resolved, yarnPackages)) {
+    return { type: "global", packageManager: "yarn" };
+  }
+  try {
+    const npmPackages = fs3.realpathSync(getNpmGlobalPackages());
+    if (isPathInside(resolved, npmPackages)) {
+      return { type: "global", packageManager: "npm" };
+    }
+  } catch {
+  }
+  if (resolved.includes("/node_modules/itsvertical/") || resolved.includes("\\node_modules\\itsvertical\\")) {
+    return { type: "local" };
+  }
+  return { type: "unknown" };
+}
+function readCache() {
+  try {
+    return JSON.parse(fs3.readFileSync(CACHE_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    fs3.mkdirSync(CACHE_DIR, { recursive: true });
+    fs3.writeFileSync(CACHE_FILE, JSON.stringify(cache));
+  } catch {
+  }
+}
+function shouldCheckForUpdate(currentVersion) {
+  if (process.env.NO_UPDATE_CHECK)
+    return false;
+  const cache = readCache();
+  if (!cache)
+    return true;
+  const scriptPath = resolveScriptPath(process.argv[1]);
+  if (cache.scriptPath !== scriptPath)
+    return true;
+  if (cache.currentVersion !== currentVersion)
+    return true;
+  if (Date.now() - cache.lastCheck >= CHECK_INTERVAL)
+    return true;
+  return false;
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+    const response = await fetch(REGISTRY_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!response.ok)
+      return null;
+    const data = await response.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function checkForUpdate(currentVersion) {
+  if (!shouldCheckForUpdate(currentVersion)) {
+    const cache = readCache();
+    if (cache && compareSemver(cache.latestVersion, currentVersion) > 0) {
+      return {
+        latestVersion: cache.latestVersion,
+        installContext: cache.installContext
+      };
+    }
+    return null;
+  }
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion)
+    return null;
+  const scriptPath = resolveScriptPath(process.argv[1]);
+  const installContext = detectInstallContext(scriptPath);
+  writeCache({
+    lastCheck: Date.now(),
+    latestVersion,
+    currentVersion,
+    installContext,
+    scriptPath
+  });
+  if (compareSemver(latestVersion, currentVersion) > 0) {
+    return { latestVersion, installContext };
+  }
+  return null;
+}
+function getUpdateCommand(context) {
+  if (context.type === "local")
+    return null;
+  if (context.type === "npx-cache")
+    return null;
+  if (context.type === "bunx-cache")
+    return null;
+  const pm = context.type === "global" ? context.packageManager : "npm";
+  switch (pm) {
+    case "npm":
+      return ["npm", "install", "-g", "itsvertical@latest"];
+    case "pnpm":
+      return ["pnpm", "add", "-g", "itsvertical@latest"];
+    case "yarn":
+      return ["yarn", "global", "add", "itsvertical@latest"];
+    case "bun":
+      return ["bun", "install", "-g", "itsvertical@latest"];
+  }
+}
+function getUpdateCommandString(context) {
+  const cmd = getUpdateCommand(context);
+  if (!cmd)
+    return "npm install -g itsvertical@latest";
+  return cmd.join(" ");
+}
+async function performUpdate(context) {
+  if (context.type === "npx-cache") {
+    try {
+      fs3.rmSync(context.cachePath, { recursive: true, force: true });
+      return {
+        success: true,
+        message: "Cleared npx cache. Next run will fetch the latest version."
+      };
+    } catch {
+      return { success: false, message: "Failed to clear npx cache." };
+    }
+  }
+  if (context.type === "bunx-cache") {
+    try {
+      for (const entry of fs3.readdirSync(context.cacheDir)) {
+        if (entry.startsWith("itsvertical@")) {
+          fs3.rmSync(path3.join(context.cacheDir, entry), {
+            recursive: true,
+            force: true
+          });
+        }
+      }
+      return {
+        success: true,
+        message: "Cleared bunx cache. Next run will fetch the latest version."
+      };
+    } catch {
+      return { success: false, message: "Failed to clear bunx cache." };
+    }
+  }
+  if (context.type === "local") {
+    return {
+      success: false,
+      message: "Cannot auto-update a local dependency. Update your package.json instead."
+    };
+  }
+  const cmd = getUpdateCommand(context);
+  if (!cmd) {
+    return { success: false, message: "Could not determine update command." };
+  }
+  return new Promise((resolve) => {
+    execFile(cmd[0], cmd.slice(1), { timeout: 6e4 }, (error) => {
+      if (error) {
+        resolve({
+          success: false,
+          message: `Update failed. Run manually: ${cmd.join(" ")}`
+        });
+      } else {
+        resolve({ success: true, message: "Updated successfully." });
+      }
+    });
+  });
+}
+async function checkAndUpdate(currentVersion) {
+  try {
+    const result = await checkForUpdate(currentVersion);
+    if (!result)
+      return;
+    if (result.installContext.type === "local")
+      return;
+    await performUpdate(result.installContext);
+  } catch {
+  }
+}
+
 // cli/index.ts
 function getDirname() {
   if (typeof __dirname !== "undefined")
@@ -2265,26 +2542,26 @@ function getDirname() {
   throw new Error("Cannot determine directory path in current environment");
 }
 var packageJson = JSON.parse(
-  fs3.readFileSync(
-    path3.resolve(getDirname(), "..", "..", "package.json"),
+  fs4.readFileSync(
+    path4.resolve(getDirname(), "..", "..", "package.json"),
     "utf8"
   )
 );
 var program = new Command();
 program.name("itsvertical").description(
-  "Tickets pile up, scopes get done. Project work isn't linear, it's Vertical."
+  "Tickets pile up, scopes get done. Project work isn't linear, it's Vertical.\n\nTip: itsvertical <file.vertical> is a shorthand for itsvertical open <file>."
 ).version(packageJson.version);
 program.command("new").description("Create a new .vertical project file").argument("<path>", "File path for the new .vertical file").argument("<name>", "Project name").option("--json", "Output as JSON").action((fileDest, name, options) => {
-  const filePath = path3.resolve(fileDest);
-  if (fs3.existsSync(filePath)) {
+  const filePath = path4.resolve(fileDest);
+  if (fs4.existsSync(filePath)) {
     fail(`File already exists: ${filePath}`, options.json);
   }
-  const dir = path3.dirname(filePath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  const dir = path4.dirname(filePath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
   }
   const state = createBlankProject(name);
-  fs3.writeFileSync(filePath, serialize(state));
+  fs4.writeFileSync(filePath, serialize(state));
   output(state, Boolean(options.json), `Created: ${filePath}`);
 });
 program.command("open").description("Open an existing .vertical file in the browser").argument("<file>", "Path to the .vertical file").action(async (file) => {
@@ -2553,10 +2830,76 @@ layer.command("status").description("Set the status of a layer").argument("<file
     );
   }
 );
+program.command("update").description("Check for and install updates").option("--json", "Output as JSON").option("--check", "Only check, do not install").action(async (options) => {
+  const result = await checkForUpdate(packageJson.version);
+  if (!result) {
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          currentVersion: packageJson.version,
+          latestVersion: packageJson.version,
+          updated: false,
+          message: "Already up to date"
+        })
+      );
+    } else {
+      console.log(`Already up to date (v${packageJson.version})`);
+    }
+    return;
+  }
+  if (options.check) {
+    if (options.json) {
+      console.log(
+        JSON.stringify({
+          currentVersion: packageJson.version,
+          latestVersion: result.latestVersion,
+          updated: false,
+          updateCommand: getUpdateCommandString(result.installContext),
+          message: `Update available: v${result.latestVersion}`
+        })
+      );
+    } else {
+      console.log(
+        `Update available: v${packageJson.version} \u2192 v${result.latestVersion}`
+      );
+      console.log(`Run: ${getUpdateCommandString(result.installContext)}`);
+    }
+    return;
+  }
+  const { success, message } = await performUpdate(result.installContext);
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        currentVersion: packageJson.version,
+        latestVersion: result.latestVersion,
+        updated: success,
+        message: success ? `Updated to v${result.latestVersion}` : message
+      })
+    );
+  } else {
+    if (success) {
+      console.log(
+        `Updated: v${packageJson.version} \u2192 v${result.latestVersion}`
+      );
+    } else {
+      console.error(`Error: ${message}`);
+    }
+  }
+  if (!success)
+    process.exit(1);
+});
 if (process.argv.length === 2) {
   program.outputHelp();
 } else {
-  program.parse(process.argv);
+  const args = process.argv.slice(2);
+  if (args.length === 1 && args[0].endsWith(".vertical")) {
+    program.parse([...process.argv.slice(0, 2), "open", args[0]]);
+  } else {
+    program.parse(process.argv);
+  }
+  if (args[0] !== "update") {
+    checkAndUpdate(packageJson.version);
+  }
 }
 /*! Bundled license information:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itsvertical",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "type": "module",
   "description": "Tickets pile up, scopes get done. Project work isn't linear, it's Vertical.",
   "license": "MIT",