@co0ontty/wand 4.30.0 → 4.31.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "e05a081ccabf4c588e9ece25430be61f0cf0cae9",
-  "builtAt": "2026-08-06T02:00:45.524Z",
-  "version": "4.30.0",
+  "commit": "963337ac2ab326332080b2ca10b39f1ccce64665",
+  "builtAt": "2026-08-06T12:29:30.333Z",
+  "version": "4.31.0",
   "channel": "stable"
 }

package/dist/server-session-routes.d.ts

@@ -5,6 +5,7 @@ import { WandStorage } from "./storage.js";
 import { ExecutionMode, SessionSnapshot, SessionSource, WandConfig } from "./types.js";
 import { toSessionListItemDTO } from "./session-transport.js";
 import { SessionRegistry } from "./session-registry.js";
+import { type SessionDirectoryNode } from "./session-directory-tree.js";
 export declare function parseExecutionMode(value: unknown, fallback: ExecutionMode): ExecutionMode;
 export declare function parseSessionCreationOrigin(body: {
     sessionSource?: unknown;
@@ -50,7 +51,15 @@ export interface SessionListPage {
     total: number;
     revision: string;
 }
+export interface SessionDirectoryTreeResponse {
+    roots: SessionDirectoryNode<SessionListPageEntry>[];
+    totalSessions: number;
+    directoryCount: number;
+    revision: string;
+}
+export declare function buildSessionListEntries(sessions: SessionSnapshot[], claudeHistory: ProviderHistorySession[], codexHistory: ProviderHistorySession[], hiddenHistoryIds: Set<string>, openCodeHistory?: ProviderHistorySession[], qoderHistory?: ProviderHistorySession[]): SessionListPageEntry[];
 export declare function buildSessionListPage(sessions: SessionSnapshot[], claudeHistory: ProviderHistorySession[], codexHistory: ProviderHistorySession[], hiddenHistoryIds: Set<string>, offset: number, limit: number, openCodeHistory?: ProviderHistorySession[], qoderHistory?: ProviderHistorySession[]): SessionListPage;
+export declare function buildSessionDirectoryTree(sessions: SessionSnapshot[], claudeHistory: ProviderHistorySession[], codexHistory: ProviderHistorySession[], hiddenHistoryIds: Set<string>, openCodeHistory?: ProviderHistorySession[], qoderHistory?: ProviderHistorySession[]): SessionDirectoryTreeResponse;
 /**
  * Provider history is scanned by ProcessManager, but structured sessions live
  * in StructuredSessionManager. Annotate against the combined session list so a

package/dist/server-session-routes.js

@@ -12,6 +12,7 @@ import { buildProviderResumeCommand, isProviderSessionId, isSafeProviderSessionI
 import { parseBoundedInteger } from "./request-limits.js";
 import { asyncRoute } from "./express-async.js";
 import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
+import { buildDirectoryTree, } from "./session-directory-tree.js";
 export function parseExecutionMode(value, fallback) {
     if (value === undefined)
         return fallback;
@@ -196,7 +197,7 @@ function sessionSortTimestamp(snapshot) {
     const timestamp = Date.parse(snapshot.startedAt);
     return Number.isFinite(timestamp) ? timestamp : 0;
 }
-export function buildSessionListPage(sessions, claudeHistory, codexHistory, hiddenHistoryIds, offset, limit, openCodeHistory = [], qoderHistory = []) {
+export function buildSessionListEntries(sessions, claudeHistory, codexHistory, hiddenHistoryIds, openCodeHistory = [], qoderHistory = []) {
     const managed = sessions.map((session) => ({
         type: "managed",
         key: `session-${session.id}`,
@@ -222,14 +223,20 @@ export function buildSessionListPage(sessions, claudeHistory, codexHistory, hidd
                 history: { ...history, provider },
             }];
     });
-    const entries = [...managed, ...recoverable].sort((left, right) => {
+    return [...managed, ...recoverable].sort((left, right) => {
         const timestampOrder = right.sortTimestamp - left.sortTimestamp;
         return timestampOrder || left.key.localeCompare(right.key);
     });
-    const boundedOffset = Math.min(Math.max(offset, 0), entries.length);
-    const revision = createHash("sha256")
+}
+function sessionListRevision(entries) {
+    return createHash("sha256")
         .update(JSON.stringify(entries.map((entry) => [entry.key, entry.sortTimestamp])))
         .digest("base64url");
+}
+export function buildSessionListPage(sessions, claudeHistory, codexHistory, hiddenHistoryIds, offset, limit, openCodeHistory = [], qoderHistory = []) {
+    const entries = buildSessionListEntries(sessions, claudeHistory, codexHistory, hiddenHistoryIds, openCodeHistory, qoderHistory);
+    const boundedOffset = Math.min(Math.max(offset, 0), entries.length);
+    const revision = sessionListRevision(entries);
     return {
         entries: entries.slice(boundedOffset, boundedOffset + limit),
         offset: boundedOffset,
@@ -237,6 +244,15 @@ export function buildSessionListPage(sessions, claudeHistory, codexHistory, hidd
         revision,
     };
 }
+export function buildSessionDirectoryTree(sessions, claudeHistory, codexHistory, hiddenHistoryIds, openCodeHistory = [], qoderHistory = []) {
+    const entries = buildSessionListEntries(sessions, claudeHistory, codexHistory, hiddenHistoryIds, openCodeHistory, qoderHistory);
+    const tree = buildDirectoryTree(entries.map((entry) => ({
+        entry,
+        cwd: entry.type === "managed" ? entry.session.cwd : entry.history.cwd,
+        sortTimestamp: entry.sortTimestamp,
+    })));
+    return { ...tree, revision: sessionListRevision(entries) };
+}
 /**
  * Provider history is scanned by ProcessManager, but structured sessions live
  * in StructuredSessionManager. Annotate against the combined session list so a
@@ -414,6 +430,14 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(500).json({ error: getErrorMessage(error, "无法加载会话列表。") });
         }
     });
+    app.get("/api/session-directories", (_req, res) => {
+        try {
+            res.json(buildSessionDirectoryTree(sessions.listSlim(), processes.listClaudeHistorySessions(), processes.listCodexHistorySessions(), getHiddenClaudeSessionIds(storage), processes.listOpenCodeHistorySessions(), processes.listQoderHistorySessions()));
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "无法加载会话目录。") });
+        }
+    });
     app.get("/api/sessions", (_req, res) => {
         res.json(sessions.listSlim().map(toSessionListItemDTO));
     });

package/dist/session-directory-tree.d.ts

@@ -0,0 +1,27 @@
+export interface SessionDirectorySource<T> {
+    entry: T;
+    cwd: string;
+    sortTimestamp: number;
+}
+export interface SessionDirectoryNode<T> {
+    /** Exact path used when starting a new session. Empty only for the synthetic unknown group. */
+    path: string;
+    /** Compact path segment label. Single-child ancestors are folded into this label. */
+    name: string;
+    synthetic: boolean;
+    /** Sessions whose cwd is exactly this node. */
+    directCount: number;
+    /** Sessions at this node or any descendant node. */
+    totalCount: number;
+    latestTimestamp: number;
+    entries: T[];
+    children: SessionDirectoryNode<T>[];
+}
+export interface SessionDirectoryTree<T> {
+    roots: SessionDirectoryNode<T>[];
+    totalSessions: number;
+    /** Number of distinct real working directories, excluding ancestor-only and unknown nodes. */
+    directoryCount: number;
+}
+export declare function normalizeSessionDirectory(value: string): string;
+export declare function buildDirectoryTree<T>(sources: readonly SessionDirectorySource<T>[], unknownLabel?: string): SessionDirectoryTree<T>;

package/dist/session-directory-tree.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+function pathApiFor(value) {
+    return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\")
+        ? path.win32
+        : path.posix;
+}
+export function normalizeSessionDirectory(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return "";
+    const api = pathApiFor(trimmed);
+    const normalized = api.normalize(trimmed);
+    const root = api.parse(normalized).root;
+    let end = normalized.length;
+    while (end > root.length && normalized[end - 1] === api.sep)
+        end -= 1;
+    return normalized.slice(0, end);
+}
+function ensureChild(parent, nodePath, name) {
+    const existing = parent.get(nodePath);
+    if (existing)
+        return existing;
+    const created = {
+        path: nodePath,
+        name,
+        synthetic: false,
+        entries: [],
+        children: new Map(),
+    };
+    parent.set(nodePath, created);
+    return created;
+}
+function insertPath(roots, cwd) {
+    const api = pathApiFor(cwd);
+    const parsed = api.parse(cwd);
+    const parts = cwd
+        .slice(parsed.root.length)
+        .split(api.sep)
+        .filter(Boolean);
+    let container = roots;
+    let currentPath = parsed.root;
+    let current = null;
+    if (parsed.root) {
+        current = ensureChild(container, parsed.root, parsed.root);
+        container = current.children;
+    }
+    for (const part of parts) {
+        currentPath = currentPath ? api.join(currentPath, part) : part;
+        current = ensureChild(container, currentPath, part);
+        container = current.children;
+    }
+    // path.normalize(".") has no segments or root. Keep it as a usable node.
+    return current ?? ensureChild(roots, cwd, cwd);
+}
+function compactLabel(parent, child, childPath) {
+    const separator = pathApiFor(childPath).sep;
+    if (parent === separator)
+        return `${separator}${child}`;
+    if (parent.endsWith(separator))
+        return `${parent}${child}`;
+    return `${parent}${separator}${child}`;
+}
+function finalizeNode(node) {
+    let children = [...node.children.values()].map(finalizeNode);
+    const sortedEntries = node.entries
+        .slice()
+        .sort((left, right) => right.sortTimestamp - left.sortTimestamp);
+    let result = {
+        path: node.path,
+        name: node.name,
+        synthetic: node.synthetic,
+        directCount: sortedEntries.length,
+        totalCount: sortedEntries.length + children.reduce((sum, child) => sum + child.totalCount, 0),
+        latestTimestamp: Math.max(0, ...sortedEntries.map((item) => item.sortTimestamp), ...children.map((child) => child.latestTimestamp)),
+        entries: sortedEntries.map((item) => item.entry),
+        children,
+    };
+    // A filesystem root followed by a single unambiguous chain is visual noise in
+    // a 280-300px sidebar. Fold it while retaining the exact descendant path.
+    while (!result.synthetic && result.directCount === 0 && result.children.length === 1) {
+        const child = result.children[0];
+        result = {
+            ...child,
+            name: compactLabel(result.name, child.name, child.path),
+        };
+    }
+    children = result.children.slice().sort((left, right) => {
+        const latestOrder = right.latestTimestamp - left.latestTimestamp;
+        return latestOrder || left.name.localeCompare(right.name);
+    });
+    return { ...result, children };
+}
+export function buildDirectoryTree(sources, unknownLabel = "未知目录") {
+    const roots = new Map();
+    let unknown = null;
+    const realDirectories = new Set();
+    for (const source of sources) {
+        const cwd = normalizeSessionDirectory(source.cwd);
+        let node;
+        if (!cwd) {
+            unknown ??= {
+                path: "",
+                name: unknownLabel,
+                synthetic: true,
+                entries: [],
+                children: new Map(),
+            };
+            node = unknown;
+        }
+        else {
+            realDirectories.add(cwd);
+            node = insertPath(roots, cwd);
+        }
+        node.entries.push({ entry: source.entry, sortTimestamp: source.sortTimestamp });
+    }
+    const finalized = [...roots.values()].map(finalizeNode);
+    if (unknown)
+        finalized.push(finalizeNode(unknown));
+    finalized.sort((left, right) => {
+        if (left.synthetic !== right.synthetic)
+            return left.synthetic ? 1 : -1;
+        const latestOrder = right.latestTimestamp - left.latestTimestamp;
+        return latestOrder || left.name.localeCompare(right.name);
+    });
+    return {
+        roots: finalized,
+        totalSessions: sources.length,
+        directoryCount: realDirectories.size,
+    };
+}