@hienlh/ppm 0.13.2 → 0.13.4

package/src/web/hooks/use-chat.ts

@@ -505,6 +505,9 @@ export function useChat(sessionId: string | null, providerId = "claude", project
       setPhase(p);
       phaseRef.current = p;
       setConnectingElapsed(p === "connecting" ? ((data as any).elapsed ?? 0) : 0);
+      // Safety: idle phase means no turn running — ensure compact indicator does not linger.
+      // BE should broadcast compact_status=done too, but this is a belt-and-braces clear.
+      if (p === "idle") setCompactStatus(null);
       return;
     }
 
@@ -523,6 +526,9 @@ export function useChat(sessionId: string | null, providerId = "claude", project
           input: state.pendingApproval.input,
         });
       }
+      // Sync compact indicator from authoritative server state (covers reconnect).
+      // state.compactStatus is "compacting" | null — treat undefined as null for back-compat.
+      setCompactStatus(state.compactStatus === "compacting" ? "compacting" : null);
       // If idle, refetch history (completed turns) and hide overlay
       if (p === "idle") {
         refetchRef.current?.();

package/src/web/hooks/use-global-keybindings.ts

@@ -4,6 +4,8 @@ import { useSettingsStore } from "@/stores/settings-store";
 import { useProjectStore } from "@/stores/project-store";
 import { useKeybindingsStore, parseCombo, eventMatchesCombo } from "@/stores/keybindings-store";
 import { useExtensionStore } from "@/stores/extension-store";
+import { useCompareStore } from "@/stores/compare-store";
+import { basename } from "@/lib/utils";
 
 /** Dispatch this event to open the command palette from anywhere, optionally with initial query */
 export function openCommandPalette(initialQuery?: string) {
@@ -156,6 +158,24 @@ export function useGlobalKeybindings() {
         return;
       }
 
+      // Compare Files — seed A from active editor tab if applicable, then open picker
+      if (match(e, "compare-files")) {
+        e.preventDefault();
+        const { activeTabId, tabs } = useTabStore.getState();
+        const active = tabs.find((t) => t.id === activeTabId);
+        const meta = active?.metadata as { filePath?: string; projectName?: string; unsavedContent?: string } | undefined;
+        if (active?.type === "editor" && meta?.filePath && meta?.projectName) {
+          useCompareStore.getState().setSelection({
+            filePath: meta.filePath,
+            projectName: meta.projectName,
+            dirtyContent: meta.unsavedContent,
+            label: basename(meta.filePath),
+          });
+        }
+        window.dispatchEvent(new CustomEvent("open-compare-picker"));
+        return;
+      }
+
       // Open search (sidebar)
       if (match(e, "open-search")) {
         e.preventDefault();

package/src/web/lib/open-compare-tab.ts

@@ -0,0 +1,76 @@
+import { api, projectUrl } from "@/lib/api-client";
+import { useTabStore } from "@/stores/tab-store";
+import { basename } from "@/lib/utils";
+
+/** One side of a compare — path + optional in-memory dirty buffer. */
+export interface CompareSide {
+  path: string;
+  dirtyContent?: string;
+}
+
+/**
+ * Open a `git-diff` tab comparing two files.
+ *
+ * Routing:
+ * - If either side has `dirtyContent` → fetch clean side via `/files/read`
+ *   and pass `original`+`modified` inline (DiffViewer's inline mode).
+ * - Else → pass `file1`+`file2` metadata (DiffViewer fetches `/files/compare`).
+ *
+ * Returns the new tab id.
+ */
+export async function openCompareTab(
+  a: CompareSide,
+  b: CompareSide,
+  projectName: string,
+): Promise<string> {
+  const title = `${basename(a.path)} ↔ ${basename(b.path)}`;
+  const aDirty = a.dirtyContent !== undefined;
+  const bDirty = b.dirtyContent !== undefined;
+
+  let metadata: Record<string, unknown>;
+
+  if (aDirty || bDirty) {
+    const [original, modified] = await Promise.all([
+      resolveSideContent(a, projectName),
+      resolveSideContent(b, projectName),
+    ]);
+    // Inline mode — DiffViewer uses `original`/`modified` when present
+    // (see diff-viewer.tsx:36 `isInline` check).
+    metadata = {
+      projectName,
+      original,
+      modified,
+      // Keep paths around for future needs (copy path, re-open source, etc.).
+      file1: a.path,
+      file2: b.path,
+    };
+  } else {
+    metadata = {
+      projectName,
+      file1: a.path,
+      file2: b.path,
+    };
+  }
+
+  const id = useTabStore.getState().openTab({
+    type: "git-diff",
+    title,
+    projectId: projectName,
+    metadata,
+    closable: true,
+  });
+  return id;
+}
+
+async function resolveSideContent(side: CompareSide, projectName: string): Promise<string> {
+  if (side.dirtyContent !== undefined) return side.dirtyContent;
+  try {
+    const { content } = await api.get<{ content: string }>(
+      `${projectUrl(projectName)}/files/read?path=${encodeURIComponent(side.path)}`,
+    );
+    return content;
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to read "${side.path}": ${reason}`);
+  }
+}

package/src/web/lib/score-file-search.ts

@@ -6,6 +6,10 @@
  *      > path contains(3) > fuzzy filename(4) > fuzzy path(5)
  *
  * Tie-breakers: shorter filename, fewer path segments.
+ *
+ * Hot-path note: callers pass PRE-LOWERCASED strings to avoid repeated
+ * allocations per keystroke. Use `scoreFileSearch` (convenience wrapper)
+ * for ad-hoc calls; use `scoreFileSearchFast` for the inner loop.
  */
 
 export interface FileSearchScore {
@@ -20,7 +24,7 @@ export interface FileSearchScore {
 }
 
 /** Extract filename from a path */
-function getFilename(path: string): string {
+export function getFilename(path: string): string {
   const i = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
   return i >= 0 ? path.slice(i + 1) : path;
 }
@@ -43,42 +47,58 @@ function fuzzyGap(query: string, text: string): number {
   return gap;
 }
 
-export function scoreFileSearch(
-  query: string,
-  label: string,
-  path: string,
+/**
+ * Fast scoring — requires pre-lowercased inputs. Use for tight loops.
+ * All string params MUST already be lowercase.
+ */
+export function scoreFileSearchFast(
+  qLower: string,
+  filenameLower: string,
+  pathLower: string,
+  labelLen: number,
+  depth: number,
 ): FileSearchScore | null {
-  const q = query.toLowerCase();
-  const nameLower = label.toLowerCase();
-  const pathLower = path.toLowerCase();
-  const filename = getFilename(pathLower);
-  const depth = path.split("/").length;
-
   // Tier 0: exact filename match
-  if (filename === q) return { tier: 0, offset: 0, nameLen: label.length, depth };
+  if (filenameLower === qLower) return { tier: 0, offset: 0, nameLen: labelLen, depth };
 
   // Tier 1: filename starts with query
-  if (filename.startsWith(q)) return { tier: 1, offset: 0, nameLen: label.length, depth };
+  if (filenameLower.startsWith(qLower)) return { tier: 1, offset: 0, nameLen: labelLen, depth };
 
   // Tier 2: filename contains query as substring
-  const fnIdx = filename.indexOf(q);
-  if (fnIdx >= 0) return { tier: 2, offset: fnIdx, nameLen: label.length, depth };
+  const fnIdx = filenameLower.indexOf(qLower);
+  if (fnIdx >= 0) return { tier: 2, offset: fnIdx, nameLen: labelLen, depth };
 
   // Tier 3: full path contains query as substring
-  const pathIdx = pathLower.indexOf(q);
-  if (pathIdx >= 0) return { tier: 3, offset: pathIdx, nameLen: label.length, depth };
+  const pathIdx = pathLower.indexOf(qLower);
+  if (pathIdx >= 0) return { tier: 3, offset: pathIdx, nameLen: labelLen, depth };
 
   // Tier 4: fuzzy match on filename
-  const fnGap = fuzzyGap(q, filename);
-  if (fnGap >= 0) return { tier: 4, offset: fnGap, nameLen: label.length, depth };
+  const fnGap = fuzzyGap(qLower, filenameLower);
+  if (fnGap >= 0) return { tier: 4, offset: fnGap, nameLen: labelLen, depth };
 
   // Tier 5: fuzzy match on full path
-  const pathGap = fuzzyGap(q, pathLower);
-  if (pathGap >= 0) return { tier: 5, offset: pathGap, nameLen: label.length, depth };
+  const pathGap = fuzzyGap(qLower, pathLower);
+  if (pathGap >= 0) return { tier: 5, offset: pathGap, nameLen: labelLen, depth };
 
   return null;
 }
 
+/** Convenience wrapper — lowers inputs on the fly. Use for ad-hoc calls. */
+export function scoreFileSearch(
+  query: string,
+  label: string,
+  path: string,
+): FileSearchScore | null {
+  const pathLower = path.toLowerCase();
+  return scoreFileSearchFast(
+    query.toLowerCase(),
+    getFilename(pathLower),
+    pathLower,
+    label.length,
+    path.split("/").length,
+  );
+}
+
 /** Compare two scores — for Array.sort (ascending = best first) */
 export function compareScores(a: FileSearchScore, b: FileSearchScore): number {
   return (

package/src/web/stores/compare-store.ts

@@ -0,0 +1,57 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { useProjectStore } from "@/stores/project-store";
+
+/** Selection captured when user picks a file "for compare". */
+export interface CompareSelection {
+  filePath: string;
+  projectName: string;
+  /** Captured snapshot of dirty editor buffer — undefined if file was clean. */
+  dirtyContent?: string;
+  /** Display name (basename) for menu/dialog UI. */
+  label: string;
+}
+
+interface CompareStore {
+  selection: CompareSelection | null;
+  setSelection: (sel: CompareSelection) => void;
+  clearSelection: () => void;
+}
+
+/** Avoid persisting huge dirty buffers (>500KB) to keep localStorage fast. */
+const MAX_DIRTY_PERSIST_BYTES = 500_000;
+
+export const useCompareStore = create<CompareStore>()(
+  persist(
+    (set) => ({
+      selection: null,
+      setSelection: (sel) => set({ selection: sel }),
+      clearSelection: () => set({ selection: null }),
+    }),
+    {
+      name: "ppm:compare-selection",
+      // Strip oversized dirtyContent before persisting — keep the path so user
+      // can still compare (content will be re-fetched from disk).
+      partialize: (s) => {
+        if (!s.selection) return { selection: null };
+        const sel = s.selection;
+        if (sel.dirtyContent && sel.dirtyContent.length > MAX_DIRTY_PERSIST_BYTES) {
+          const { dirtyContent: _, ...rest } = sel;
+          return { selection: rest };
+        }
+        return { selection: sel };
+      },
+    },
+  ),
+);
+
+// Auto-clear selection when the user switches active project.
+// Tracked in module scope to avoid clearing on the initial load hydration.
+let lastActiveProject: string | null = null;
+useProjectStore.subscribe((state) => {
+  const now = state.activeProject?.name ?? null;
+  if (lastActiveProject !== null && lastActiveProject !== now) {
+    useCompareStore.getState().clearSelection();
+  }
+  lastActiveProject = now;
+});

package/src/web/stores/keybindings-store.ts

@@ -37,6 +37,7 @@ export const KEY_ACTIONS: KeyAction[] = [
   { id: "open-git-status", label: "Git Status (sidebar)", category: "tabs", defaultKey: "Mod+Shift+E" },
   { id: "open-search", label: "Search Files (sidebar)", category: "tabs", defaultKey: "Mod+Shift+F" },
   { id: "voice-input", label: "Voice Input", category: "general", defaultKey: "Mod+Shift+V", note: "Toggle speech-to-text in chat" },
+  { id: "compare-files", label: "Compare Files...", category: "general", defaultKey: "Mod+Alt+D", note: "Open file-compare picker (seeds active file as A)" },
   // Projects — Mod+1..9
   ...Array.from({ length: 9 }, (_, i) => ({
     id: `switch-project-${i + 1}`,

package/dist/web/assets/architecture-PBZL5I3N-DvZbltvY.js

@@ -1 +0,0 @@
-import{W as e}from"./vendor-mermaid-Dx86tuVP.js";export{e as createArchitectureServices};