itsvertical 0.0.9 → 0.0.10

package/README.md

@@ -95,6 +95,16 @@ itsvertical layer status <file> <layer-id> done # Set status to "done"
 itsvertical layer status <file> <layer-id> none # Clear status
 ```
 
+### Board History
+
+Vertical automatically tracks boards you create and open in `~/.vertical/history.json`.
+
+```
+itsvertical history list                       # List all known boards
+itsvertical history add <file>                 # Manually add a board to history
+itsvertical history remove <name-or-file>      # Remove a board from history
+```
+
 ### Browser UI
 
 `itsvertical open` (or just `itsvertical <file>`) starts a local server and opens the board in your browser. Changes are saved automatically.
@@ -108,6 +118,7 @@ Each box represents a vertical slice of work.
 - **Add tasks** by clicking the input at the bottom of a box
 - **Edit tasks** by clicking on them
 - **Mark tasks done** with the circle checkbox
+- **Add notes** to a task by clicking the sticky note icon (rich text editor with formatting, slash commands, and code blocks)
 - **Drag tasks** between boxes and layers
 - **Split layers** with the scissor tool (click ✂ or press **S**, then click a task to split at that point)
 - **Unsplit layers** by focusing the dashed separator and pressing **Delete**

package/cli/dist/index.js

@@ -1472,8 +1472,8 @@ var require_react = __commonJS({
 });
 
 // cli/index.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { dirname } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
@@ -2105,10 +2105,70 @@ function showSummaryTable(state, boxId) {
   console.log(hLine("\u2514", "\u2534", "\u2518"));
 }
 
-// cli/server.ts
+// cli/history.ts
 import fs2 from "fs";
-import http from "http";
+import os from "os";
 import path2 from "path";
+function getHistoryDir() {
+  return path2.join(os.homedir(), ".vertical");
+}
+function getHistoryPath() {
+  return path2.join(getHistoryDir(), "history.json");
+}
+function ensureHistoryDir() {
+  const dir = getHistoryDir();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+function loadHistory() {
+  const historyPath = getHistoryPath();
+  if (!fs2.existsSync(historyPath)) {
+    return { version: 1, boards: [] };
+  }
+  const content = fs2.readFileSync(historyPath, "utf-8");
+  return JSON.parse(content);
+}
+function saveHistory(history2) {
+  ensureHistoryDir();
+  fs2.writeFileSync(getHistoryPath(), JSON.stringify(history2, null, 2));
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function recordBoard(name, filePath) {
+  const history2 = loadHistory();
+  const slug = slugify(name);
+  const existing = history2.boards.find((b) => slugify(b.name) === slug);
+  if (existing && existing.filePath !== filePath) {
+    throw new Error(
+      `A board named "${existing.name}" is already tracked at: ${existing.filePath}`
+    );
+  }
+  if (!existing) {
+    history2.boards.push({ name, filePath });
+    saveHistory(history2);
+  }
+}
+function forgetBoard(nameOrPath) {
+  const history2 = loadHistory();
+  const slug = slugify(nameOrPath);
+  const absolutePath = path2.resolve(nameOrPath);
+  const index = history2.boards.findIndex(
+    (b) => slugify(b.name) === slug || b.filePath === absolutePath
+  );
+  if (index === -1) {
+    return false;
+  }
+  history2.boards.splice(index, 1);
+  saveHistory(history2);
+  return true;
+}
+
+// cli/server.ts
+import fs3 from "fs";
+import http from "http";
+import path3 from "path";
 import readline from "readline";
 import { fileURLToPath } from "url";
 import getPort from "get-port";
@@ -2126,24 +2186,24 @@ var MIME_TYPES = {
   ".woff2": "font/woff2"
 };
 function getDistPath() {
-  const currentDir = path2.dirname(fileURLToPath(import.meta.url));
-  return path2.resolve(currentDir, "..", "..", "dist");
+  const currentDir = path3.dirname(fileURLToPath(import.meta.url));
+  return path3.resolve(currentDir, "..", "..", "dist");
 }
 function serveStaticFile(res, distPath, urlPath) {
-  const filePath = path2.join(distPath, urlPath);
-  const safePath = path2.resolve(filePath);
+  const filePath = path3.join(distPath, urlPath);
+  const safePath = path3.resolve(filePath);
   if (!safePath.startsWith(distPath)) {
     res.writeHead(403);
     res.end("Forbidden");
     return;
   }
-  if (!fs2.existsSync(safePath) || fs2.statSync(safePath).isDirectory()) {
+  if (!fs3.existsSync(safePath) || fs3.statSync(safePath).isDirectory()) {
     return false;
   }
-  const ext = path2.extname(safePath);
+  const ext = path3.extname(safePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
   res.writeHead(200, { "Content-Type": contentType });
-  fs2.createReadStream(safePath).pipe(res);
+  fs3.createReadStream(safePath).pipe(res);
   return true;
 }
 function readRequestBody(req) {
@@ -2169,10 +2229,10 @@ function confirm(question) {
   });
 }
 async function startServer(filePath, options = {}) {
-  const absoluteFilePath = path2.resolve(filePath);
+  const absoluteFilePath = path3.resolve(filePath);
   const distPath = getDistPath();
   let browserDirty = false;
-  if (!fs2.existsSync(distPath)) {
+  if (!fs3.existsSync(distPath)) {
     console.error(
       "Error: dist/ directory not found. Run `pnpm run build` first."
     );
@@ -2181,14 +2241,14 @@ async function startServer(filePath, options = {}) {
   const server = http.createServer(async (req, res) => {
     const url2 = req.url || "/";
     if (url2 === "/api/project" && req.method === "GET") {
-      const content = fs2.readFileSync(absoluteFilePath, "utf-8");
+      const content = fs3.readFileSync(absoluteFilePath, "utf-8");
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(content);
       return;
     }
     if (url2 === "/api/project" && req.method === "POST") {
       const body = await readRequestBody(req);
-      fs2.writeFileSync(absoluteFilePath, body);
+      fs3.writeFileSync(absoluteFilePath, body);
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end('{"ok":true}');
       return;
@@ -2212,10 +2272,10 @@ async function startServer(filePath, options = {}) {
     }
     if (serveStaticFile(res, distPath, url2))
       return;
-    const indexPath = path2.join(distPath, "index.html");
-    if (fs2.existsSync(indexPath)) {
+    const indexPath = path3.join(distPath, "index.html");
+    if (fs3.existsSync(indexPath)) {
       res.writeHead(200, { "Content-Type": "text/html" });
-      fs2.createReadStream(indexPath).pipe(res);
+      fs3.createReadStream(indexPath).pipe(res);
       return;
     }
     res.writeHead(404);
@@ -2224,7 +2284,7 @@ async function startServer(filePath, options = {}) {
   const port = options.port ?? await getPort();
   const url = `http://localhost:${port}`;
   const sseClients = /* @__PURE__ */ new Set();
-  fs2.watch(absoluteFilePath, () => {
+  fs3.watch(absoluteFilePath, () => {
     for (const client of sseClients) {
       client.write("data: file-changed\n\n");
     }
@@ -2257,11 +2317,11 @@ 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");
+import fs4 from "fs";
+import os2 from "os";
+import path4 from "path";
+var CACHE_DIR = path4.join(os2.homedir(), ".itsvertical");
+var CACHE_FILE = path4.join(CACHE_DIR, "update-check.json");
 var CHECK_INTERVAL = 36e5;
 var FETCH_TIMEOUT = 5e3;
 var REGISTRY_URL = "https://registry.npmjs.org/itsvertical/latest";
@@ -2279,12 +2339,12 @@ function compareSemver(a, b) {
   return 0;
 }
 function isPathInside(childPath, parentPath) {
-  const relative = path3.relative(parentPath, childPath);
-  return relative !== "" && !relative.startsWith("..") && !path3.isAbsolute(relative);
+  const relative = path4.relative(parentPath, childPath);
+  return relative !== "" && !relative.startsWith("..") && !path4.isAbsolute(relative);
 }
 function resolveScriptPath(scriptPath) {
   try {
-    return fs3.realpathSync(scriptPath);
+    return fs4.realpathSync(scriptPath);
   } catch {
     return scriptPath;
   }
@@ -2296,46 +2356,46 @@ function getNpmGlobalPackages() {
   );
   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");
+    const prefix2 = path4.resolve(envValue);
+    return path4.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);
+    prefix = process.env.APPDATA ? path4.join(process.env.APPDATA, "npm") : path4.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));
+    prefix = path4.dirname(path4.dirname(process.execPath));
   }
-  return path3.join(prefix, isWindows ? "node_modules" : "lib/node_modules");
+  return path4.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");
+    return path4.join(process.env.XDG_DATA_HOME, "pnpm");
   if (process.platform === "darwin")
-    return path3.join(os.homedir(), "Library/pnpm");
+    return path4.join(os2.homedir(), "Library/pnpm");
   if (process.platform !== "win32")
-    return path3.join(os.homedir(), ".local/share/pnpm");
+    return path4.join(os2.homedir(), ".local/share/pnpm");
   if (process.env.LOCALAPPDATA)
-    return path3.join(process.env.LOCALAPPDATA, "pnpm");
-  return path3.join(os.homedir(), ".pnpm");
+    return path4.join(process.env.LOCALAPPDATA, "pnpm");
+  return path4.join(os2.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");
+    dataDir = process.env.LOCALAPPDATA ? path4.join(process.env.LOCALAPPDATA, "Yarn/Data") : path4.join(os2.homedir(), ".config/yarn");
   } else if (process.env.XDG_DATA_HOME) {
-    dataDir = path3.join(process.env.XDG_DATA_HOME, "yarn");
+    dataDir = path4.join(process.env.XDG_DATA_HOME, "yarn");
   } else {
-    dataDir = path3.join(os.homedir(), ".config/yarn");
+    dataDir = path4.join(os2.homedir(), ".config/yarn");
   }
-  return path3.join(dataDir, "global/node_modules");
+  return path4.join(dataDir, "global/node_modules");
 }
 function getBunGlobalDir() {
-  return process.env.BUN_INSTALL || path3.join(os.homedir(), ".bun");
+  return process.env.BUN_INSTALL || path4.join(os2.homedir(), ".bun");
 }
 function detectInstallContext(scriptPath) {
   const resolved = resolveScriptPath(scriptPath);
@@ -2343,24 +2403,24 @@ function detectInstallContext(scriptPath) {
   if (npxMatch) {
     return { type: "npx-cache", cachePath: npxMatch[1] };
   }
-  const bunDir = path3.resolve(getBunGlobalDir());
+  const bunDir = path4.resolve(getBunGlobalDir());
   if (isPathInside(resolved, bunDir)) {
-    const bunCacheDir = path3.join(bunDir, "install", "cache");
+    const bunCacheDir = path4.join(bunDir, "install", "cache");
     if (isPathInside(resolved, bunCacheDir)) {
       return { type: "bunx-cache", cacheDir: bunCacheDir };
     }
     return { type: "global", packageManager: "bun" };
   }
-  const pnpmDir = path3.resolve(getPnpmGlobalDir());
+  const pnpmDir = path4.resolve(getPnpmGlobalDir());
   if (isPathInside(resolved, pnpmDir)) {
     return { type: "global", packageManager: "pnpm" };
   }
-  const yarnPackages = path3.resolve(getYarnGlobalPackages());
+  const yarnPackages = path4.resolve(getYarnGlobalPackages());
   if (isPathInside(resolved, yarnPackages)) {
     return { type: "global", packageManager: "yarn" };
   }
   try {
-    const npmPackages = fs3.realpathSync(getNpmGlobalPackages());
+    const npmPackages = fs4.realpathSync(getNpmGlobalPackages());
     if (isPathInside(resolved, npmPackages)) {
       return { type: "global", packageManager: "npm" };
     }
@@ -2373,15 +2433,15 @@ function detectInstallContext(scriptPath) {
 }
 function readCache() {
   try {
-    return JSON.parse(fs3.readFileSync(CACHE_FILE, "utf-8"));
+    return JSON.parse(fs4.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));
+    fs4.mkdirSync(CACHE_DIR, { recursive: true });
+    fs4.writeFileSync(CACHE_FILE, JSON.stringify(cache));
   } catch {
   }
 }
@@ -2470,7 +2530,7 @@ function getUpdateCommandString(context) {
 async function performUpdate(context) {
   if (context.type === "npx-cache") {
     try {
-      fs3.rmSync(context.cachePath, { recursive: true, force: true });
+      fs4.rmSync(context.cachePath, { recursive: true, force: true });
       return {
         success: true,
         message: "Cleared npx cache. Next run will fetch the latest version."
@@ -2481,9 +2541,9 @@ async function performUpdate(context) {
   }
   if (context.type === "bunx-cache") {
     try {
-      for (const entry of fs3.readdirSync(context.cacheDir)) {
+      for (const entry of fs4.readdirSync(context.cacheDir)) {
         if (entry.startsWith("itsvertical@")) {
-          fs3.rmSync(path3.join(context.cacheDir, entry), {
+          fs4.rmSync(path4.join(context.cacheDir, entry), {
             recursive: true,
             force: true
           });
@@ -2542,8 +2602,8 @@ function getDirname() {
   throw new Error("Cannot determine directory path in current environment");
 }
 var packageJson = JSON.parse(
-  fs4.readFileSync(
-    path4.resolve(getDirname(), "..", "..", "package.json"),
+  fs5.readFileSync(
+    path5.resolve(getDirname(), "..", "..", "package.json"),
     "utf8"
   )
 );
@@ -2552,20 +2612,33 @@ program.name("itsvertical").description(
   "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 = path4.resolve(fileDest);
-  if (fs4.existsSync(filePath)) {
+  const filePath = path5.resolve(fileDest);
+  if (fs5.existsSync(filePath)) {
     fail(`File already exists: ${filePath}`, options.json);
   }
-  const dir = path4.dirname(filePath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const dir = path5.dirname(filePath);
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
   const state = createBlankProject(name);
-  fs4.writeFileSync(filePath, serialize(state));
+  fs5.writeFileSync(filePath, serialize(state));
+  try {
+    recordBoard(name, filePath);
+  } catch (error) {
+    fail(error.message, options.json);
+  }
   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) => {
   const filePath = resolveFilePath(file);
+  const state = loadState(filePath);
+  try {
+    recordBoard(state.project.name, filePath);
+  } catch (error) {
+    console.warn(
+      `Warning: could not track board: ${error.message}`
+    );
+  }
   await startServer(filePath);
 });
 program.command("dev").description("Start dev server (fixed port, no browser open)").argument("<file>", "Path to the .vertical file").action(async (file) => {
@@ -2597,6 +2670,53 @@ program.command("rename").description("Rename the project").argument("<file>", "
   const state = applyAction(filePath, { type: "RENAME_PROJECT", name });
   output(state, Boolean(options.json), `Project renamed to: ${name}`);
 });
+var history = program.command("history").description("Manage board history");
+history.command("list").description("List all known boards").option("--json", "Output as JSON").action((options) => {
+  const boardHistory = loadHistory();
+  if (options.json) {
+    const entries = boardHistory.boards.map((b) => ({
+      name: b.name,
+      filePath: b.filePath,
+      exists: fs5.existsSync(b.filePath)
+    }));
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  if (boardHistory.boards.length === 0) {
+    console.log("No boards known yet. Create or open a board to get started.");
+    return;
+  }
+  for (const board of boardHistory.boards) {
+    const exists = fs5.existsSync(board.filePath);
+    const marker = exists ? "" : " (missing)";
+    console.log(`${board.name}  ${board.filePath}${marker}`);
+  }
+});
+history.command("add").description("Add an existing .vertical file to history").argument("<file>", "Path to the .vertical file").option("--json", "Output as JSON").action((file, options) => {
+  const filePath = resolveFilePath(file, options.json);
+  const state = loadState(filePath);
+  try {
+    recordBoard(state.project.name, filePath);
+  } catch (error) {
+    fail(error.message, options.json);
+  }
+  output(
+    state,
+    Boolean(options.json),
+    `Added to history: ${state.project.name} \u2192 ${filePath}`
+  );
+});
+history.command("remove").description("Remove a board from history (does not delete the file)").argument("<name-or-file>", "Board name or file path").option("--json", "Output as JSON").action((nameOrFile, options) => {
+  const removed = forgetBoard(nameOrFile);
+  if (!removed) {
+    fail(`Board not found in history: "${nameOrFile}"`, options.json);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ success: true }));
+  } else {
+    console.log(`Removed from history: ${nameOrFile}`);
+  }
+});
 var task = program.command("task").description("Manage tasks");
 task.command("add").description("Add a task to a layer").argument("<file>", "Path to the .vertical file").argument("<layer-id>", "Layer ID to add the task to").argument("<name>", "Task name").option("--json", "Output as JSON").option("--after <task-id>", "Insert after a specific task").action(
   (file, layerId, name, options) => {

package/package.json

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