kandown 0.21.7 → 0.23.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.23.0 — 2026-07-20 — "Theme Switcher & Auto Update"
+
+- **Added**: **Animated Theme Switcher** — added a shadcn-style three-option theme switcher under `src/components/ui/theme-switcher-1.tsx` with system, light, and dark choices, lucide icons, and Motion layout animation.
+- **Changed**: **Theme Mode UX** — replaced the Appearance settings theme dropdown and the old header two-state toggle with the new animated switcher. The component keeps Kandown's existing `auto`, `light`, and `dark` config values so existing `.kandown/kandown.json` files remain compatible.
+- **Changed**: **Framework Integration** — adapted the provided `next-themes` component to Kandown's Vite/Zustand theme pipeline instead of adding a Next.js-only provider. Theme changes continue to persist through the existing project config and apply via the local CSS token engine.
+- **Fixed**: **Auto-Updater Retry Blocking** — failed auto-update installs are no longer cached as a successful update check. Previously, if npm answered the registry but the install failed, Kandown could suppress retries for 24 hours, making auto-update feel blocked across open projects.
+- **Fixed**: **Multi-Project Auto-Update Refresh** — after a successful in-place global update, Kandown now scans active local daemons and refreshes `kandown.html` for every open project, so two simultaneously open boards do not remain stuck on different web UI bundles.
+- **Fixed**: **Installed Version Verification** — the auto-updater now verifies the installed Kandown CLI version instead of only checking the npm registry version, making successful restart decisions based on the actual local binary.
+
+## 0.22.0 — 2026-07-20 — "Sectioned List View"
+
+- **Added**: **Sectioned List View** — rebuilt the web List view so board columns such as Backlog, Todo, In Progress, Review, and Done are displayed as horizontal task sections stacked vertically. This keeps the dense list/table workflow while making the List view match the mental model of the Kanban board in the opposite orientation.
+- **Added**: **Vertical Section Drag-and-Drop** — added gripper-based drag-and-drop for List view sections. Reordering sections persists through the existing `reorderColumns` store action, so the same column order is shared by Board view, List view, config, and future reloads.
+- **Added**: **Task Drag-and-Drop Between List Sections** — task rows in List view can now be dragged between sections to change their status. Drops reuse the existing `moveTask` persistence path, including dependency gates, optimistic updates, rollback behavior, and markdown frontmatter writes.
+- **Changed**: **List View Layout** — replaced the previous single flat table with per-column section headers, task counts, repeated metadata headers, section drop guides, and empty-section drop targets. Search, filters, due-date summaries, metadata columns, drawer opening, and search-preview snippets continue to work inside the new sectioned layout.
+- **Fixed**: **Scripted CLI Commands Exit Cleanly** — one-shot commands such as `kandown doctor` and `kandown list --json` now terminate explicitly after their handler finishes. This prevents passive bundled dependency handles from keeping scripted commands alive after successful output, preserving reliable CI and agent pipeline behavior.
+
 ## 0.21.7 — 2026-07-20 — "Web UI Vector Logo & CLI Changelog Fix"
 
 - **Added**: **Vector Brand Logo Component (`LogoSvg.tsx`)** — unified header and empty state UI components to render the official multi-color brand vector logo from `logo.svg`.

package/README.md

@@ -169,7 +169,7 @@ Interactive runs of `kandown` check npm for updates at most once every 24 hours
 | Feature | Description |
 |---|---|
 | Board view | Horizontal kanban with drag-and-drop |
-| List view | Dense table with filters & search |
+| List view | Sectioned vertical list with filters, search, and drag-and-drop between statuses |
 | Content search | Search titles, body, subtasks, tags, assignee, priority |
 | Command palette | `⌘K` / `Ctrl+K` for quick actions |
 | Custom columns | Add, rename, delete columns freely |

package/bin/kandown.js

@@ -145,6 +145,32 @@ function resolveKandownBin() {
   return null;
 }
 
+async function readInstalledKandownVersion(targetVersion) {
+  const localVersion = getCurrentVersion();
+  if (localVersion && semverGt(localVersion, targetVersion) >= 0) return localVersion;
+
+  const bin = resolveKandownBin();
+  if (!bin) return localVersion;
+
+  return await new Promise((resolveVersion) => {
+    const child = spawn(bin, ['--version'], {
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, KANDOWN_NO_UPDATE: '1' },
+      detached: false,
+    });
+    let stdout = '';
+    child.stdout.on('data', (d) => { stdout += d; });
+    child.stderr.on('data', () => {});
+    child.on('error', () => resolveVersion(localVersion));
+    child.on('close', (code) => {
+      if (code !== 0) return resolveVersion(localVersion);
+      const match = stdout.trim().match(/v?(\d+\.\d+\.\d+(?:-[\w.-]+)?)/);
+      resolveVersion(match ? match[1] : localVersion);
+    });
+  });
+}
+
 /**
  * 📖 Compares two semver strings (major.minor.patch, optional -prerelease).
  * Prerelease-safe: "0.18.0-beta.1" no longer parses as NaN — the numeric
@@ -260,11 +286,15 @@ async function checkForUpdate(argv = process.argv) {
     });
   });
 
-  // 📖 A successful registry answer (even "up to date") arms the 24h throttle.
-  // Offline / registry-down does NOT — we retry on the next interactive run.
-  if (latest) rememberUpdateCheck();
+  if (!latest) return; // offline / registry-down — retry on the next interactive run
 
-  if (!latest || semverGt(current, latest) >= 0) return; // up to date or offline
+  if (semverGt(current, latest) >= 0) {
+    // 📖 Up-to-date registry answers can be throttled. Failed update attempts
+    // below are intentionally NOT cached, otherwise one broken install would
+    // silence auto-update retries for 24h across every open project.
+    rememberUpdateCheck();
+    return;
+  }
 
   tuiDone('⚡', `Update available: ${c.dim}kandown ${current}${c.reset} → ${c.green}${latest}${c.reset}`);
 
@@ -305,22 +335,9 @@ async function checkForUpdate(argv = process.argv) {
     return;
   }
 
-  // 📖 Step 4: Verify the update actually landed.
-  const postVersion = await new Promise((resolve) => {
-    const child = spawn('npm', ['view', 'kandown', 'version'], {
-      timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      detached: false,
-    });
-    let stdout = '';
-    child.stdout.on('data', (d) => { stdout += d; });
-    child.stderr.on('data', () => {});
-    child.on('error', () => resolve(null));
-    child.on('close', (code) => {
-      if (code !== 0) return resolve(null);
-      resolve(stdout.trim().replace(/^"|"$/g, '') || null);
-    });
-  });
+  // 📖 Step 4: Verify the installed CLI, not just the npm registry, because
+  // `npm view kandown version` only proves a version exists remotely.
+  const postVersion = await readInstalledKandownVersion(latest);
 
   if (!postVersion || semverGt(postVersion, latest) < 0) {
     tuiDone('✗', `${c.yellow}Update did not apply${c.reset} — continuing with current version`);
@@ -329,6 +346,18 @@ async function checkForUpdate(argv = process.argv) {
     return;
   }
 
+  rememberUpdateCheck();
+
+  // 📖 If the running package directory has been replaced in-place (normal
+  // global install), refresh every currently open project daemon, not only the
+  // project that triggered the update. This keeps two simultaneously open
+  // Kandown boards from getting stuck on different kandown.html versions.
+  const localVersionAfterInstall = getCurrentVersion();
+  if (localVersionAfterInstall && semverGt(localVersionAfterInstall, latest) >= 0) {
+    const refreshed = await refreshRunningProjectHtml();
+    if (refreshed > 0) info(`Refreshed ${refreshed} open project${refreshed === 1 ? '' : 's'}`);
+  }
+
   tuiDone('✓', `${c.green}Updated to v${postVersion}${c.reset} — restarting…`);
   printVersionChangelog(postVersion);
   printBreakingChangeNotices(current, postVersion);
@@ -1785,6 +1814,28 @@ function refreshKandownHtml(kandownDir) {
   return false;
 }
 
+async function refreshRunningProjectHtml() {
+  const ports = [];
+  for (let port = START_PORT_RANGE; port <= END_PORT_RANGE; port++) {
+    if (!isBrowserUnsafePort(port)) ports.push(port);
+  }
+
+  const daemons = await Promise.all(ports.map(port => fetchDaemonInfo(port)));
+  const kandownDirs = new Set(
+    daemons
+      .map(daemon => daemon?.kandownDir)
+      .filter(dir => typeof dir === 'string' && dir.length > 0)
+  );
+
+  let refreshed = 0;
+  for (const kandownDir of kandownDirs) {
+    try {
+      if (refreshKandownHtml(kandownDir)) refreshed++;
+    } catch { /* best-effort: one locked project must not block restart */ }
+  }
+  return refreshed;
+}
+
 async function waitForDaemon(kandownDir, timeoutMs = 8000) {
   // 📖 Detect daemon startup via TCP probe + process liveness rather than HTTP
   // fetch. The freshly spawned child is known to be ours, so once its process
@@ -3228,3 +3279,12 @@ switch (cmd) {
     help();
     process.exit(1);
 }
+
+// 📖 Some bundled/imported dependencies can leave passive handles alive even
+// after a one-shot CLI command has finished its synchronous work. Scripted
+// commands must be pipeline-safe, so terminate explicitly once their handler
+// returns. The daemon runner, MCP server, and interactive TUI paths are the
+// long-lived exceptions.
+if (SCRIPTED_COMMANDS.has(cmd) && !(cmd === 'daemon' && rest[0] === 'run')) {
+  process.exit(0);
+}