@hienlh/ppm 0.10.5 → 0.11.0

package/src/types/jira.ts

@@ -0,0 +1,128 @@
+// ── DB row types (snake_case, matches SQLite columns) ─────────────────
+
+export interface JiraConfigRow {
+  id: number;
+  project_id: number;
+  base_url: string;
+  email: string;
+  api_token_encrypted: string;
+  created_at: string;
+}
+
+export interface JiraWatcherRow {
+  id: number;
+  jira_config_id: number;
+  name: string;
+  jql: string;
+  prompt_template: string | null;
+  enabled: number; // 0 | 1
+  mode: string; // "debug" | "notify"
+  interval_ms: number;
+  last_polled_at: string | null;
+  created_at: string;
+}
+
+export interface JiraWatchResultRow {
+  id: number;
+  watcher_id: number | null;
+  issue_key: string;
+  issue_summary: string | null;
+  issue_updated: string | null;
+  session_id: string | null;
+  status: JiraResultStatus;
+  ai_summary: string | null;
+  source: string; // "watcher" | "manual"
+  deleted: number; // 0 | 1
+  read_at: string | null;
+  triggered_by: string; // "auto" | "manual"
+  created_at: string;
+}
+
+export type JiraResultStatus = "pending" | "queued" | "running" | "done" | "failed";
+export type JiraWatcherMode = "debug" | "notify";
+
+// ── API response types (camelCase for frontend) ───────────────────────
+
+export interface JiraConfig {
+  id: number;
+  projectId: number;
+  baseUrl: string;
+  email: string;
+  hasToken: boolean; // never expose actual token
+  createdAt: string;
+}
+
+export interface JiraWatcher {
+  id: number;
+  jiraConfigId: number;
+  name: string;
+  jql: string;
+  promptTemplate: string | null;
+  enabled: boolean;
+  mode: JiraWatcherMode;
+  intervalMs: number;
+  lastPolledAt: string | null;
+  createdAt: string;
+}
+
+export interface JiraWatchResult {
+  id: number;
+  watcherId: number | null;
+  issueKey: string;
+  issueSummary: string | null;
+  issueUpdated: string | null;
+  sessionId: string | null;
+  status: JiraResultStatus;
+  aiSummary: string | null;
+  source: string;
+  readAt: string | null;
+  triggeredBy: string;
+  createdAt: string;
+}
+
+// ── Jira Cloud API response shapes (subset we use) ────────────────────
+
+export interface JiraIssue {
+  key: string;
+  id: string;
+  fields: {
+    summary: string;
+    description: string | null;
+    status: { name: string; id: string };
+    priority: { name: string; id: string } | null;
+    assignee: { accountId: string; displayName: string; emailAddress?: string } | null;
+    updated: string;
+    created: string;
+  };
+}
+
+export interface JiraSearchResponse {
+  issues: JiraIssue[];
+  total: number;
+  maxResults: number;
+  nextPageToken?: string;
+}
+
+export interface JiraTransition {
+  id: string;
+  name: string;
+  to: { name: string };
+}
+
+// ── Credentials (internal, decrypted for API calls) ───────────────────
+
+export interface JiraCredentials {
+  baseUrl: string;
+  email: string;
+  token: string; // plaintext (decrypted)
+}
+
+// ── Rate limit tracking ───────────────────────────────────────────────
+
+export interface JiraRateLimitState {
+  remaining: number | null;
+  limit: number | null;
+  resetAt: string | null;
+  backingOff: boolean;
+  pausedUntil: number | null; // epoch ms
+}

package/src/web/app.tsx

@@ -178,19 +178,22 @@ export function App() {
 
       useProjectStore.getState().setActiveProject(target);
 
+      // Switch panel layout to target project BEFORE opening URL tabs.
+      // Without this, autoOpenFromUrl creates tabs in the __global__ layout
+      // which get lost when the switchProject effect fires after render.
+      useTabStore.getState().switchProject(target.name);
+
       // Auto-open target tab from URL (type-based)
-      queueMicrotask(() => {
-        if (urlState.tabType) {
-          autoOpenFromUrl(urlState.tabType, urlState.tabIdentifier, target!.name);
-        }
-        // Legacy: ?openChat= query param
-        if (urlState.openChat) {
-          autoOpenFromUrl("chat", urlState.openChat, target!.name);
-          const url = new URL(window.location.href);
-          url.searchParams.delete("openChat");
-          window.history.replaceState(null, "", url.pathname);
-        }
-      });
+      if (urlState.tabType) {
+        autoOpenFromUrl(urlState.tabType, urlState.tabIdentifier, target!.name);
+      }
+      // Legacy: ?openChat= query param
+      if (urlState.openChat) {
+        autoOpenFromUrl("chat", urlState.openChat, target!.name);
+        const url = new URL(window.location.href);
+        url.searchParams.delete("openChat");
+        window.history.replaceState(null, "", url.pathname);
+      }
     });
   }, [authState, fetchProjects]);
 

package/src/web/components/chat/chat-tab.tsx

@@ -57,6 +57,8 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
   // Drag-and-drop state
   const [isDragging, setIsDragging] = useState(false);
   const [externalFiles, setExternalFiles] = useState<File[] | null>(null);
+  const [externalPaths, setExternalPaths] = useState<string[] | null>(null);
+  const [disambiguateItems, setDisambiguateItems] = useState<FileNode[] | null>(null);
   const dragCounterRef = useRef(0);
 
   // Use tab's own project, not global activeProject (keep-alive: hidden tabs must not react to switches)
@@ -285,6 +287,16 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     setSlashFilter("");
   }, []);
 
+  // --- Disambiguation picker handler (OS drag resolve with multiple matches) ---
+  const handleDisambiguate = useCallback((matches: FileNode[]) => {
+    setDisambiguateItems(matches);
+  }, []);
+
+  const handleDisambiguateSelect = useCallback((item: FileNode) => {
+    setExternalPaths([item.path]);
+    setDisambiguateItems(null);
+  }, []);
+
   // --- File picker handlers ---
   const handleFileStateChange = useCallback((visible: boolean, filter: string) => {
     setShowFilePicker(visible);
@@ -307,7 +319,7 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
   const handleDragEnter = useCallback((e: DragEvent) => {
     e.preventDefault();
     dragCounterRef.current++;
-    if (e.dataTransfer.types.includes("Files")) {
+    if (e.dataTransfer.types.includes("application/x-ppm-path") || e.dataTransfer.types.includes("Files")) {
       setIsDragging(true);
     }
   }, []);
@@ -329,6 +341,13 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
     dragCounterRef.current = 0;
     setIsDragging(false);
 
+    // Check for internal file tree drag (custom MIME) first
+    const ppmPath = e.dataTransfer.getData("application/x-ppm-path");
+    if (ppmPath) {
+      setExternalPaths([ppmPath]);
+      return;
+    }
+
     const files = Array.from(e.dataTransfer.files);
     if (files.length > 0) {
       setExternalFiles(files);
@@ -422,6 +441,15 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           onClose={handleFileClose}
           visible={showFilePicker}
         />
+        {disambiguateItems && (
+          <FilePicker
+            items={disambiguateItems}
+            filter=""
+            onSelect={handleDisambiguateSelect}
+            onClose={() => setDisambiguateItems(null)}
+            visible={true}
+          />
+        )}
 
         {/* Input */}
         <MessageInput
@@ -438,6 +466,9 @@ export function ChatTab({ metadata, tabId }: ChatTabProps) {
           onFileItemsLoaded={setFileItems}
           fileSelected={fileSelected}
           externalFiles={externalFiles}
+          externalPaths={externalPaths}
+          onExternalPathsConsumed={() => setExternalPaths(null)}
+          onDisambiguate={handleDisambiguate}
           permissionMode={permissionMode}
           onModeChange={setPermissionMode}
           providerId={providerId}

package/src/web/components/chat/message-input.tsx

@@ -40,6 +40,12 @@ interface MessageInputProps {
   fileSelected?: FileNode | null;
   /** External files added via drag-drop on parent */
   externalFiles?: File[] | null;
+  /** External paths from file tree drag or disambiguation */
+  externalPaths?: string[] | null;
+  /** Callback when external paths have been consumed (inserted into textarea) */
+  onExternalPathsConsumed?: () => void;
+  /** Callback when OS-dropped files resolve to multiple matches (disambiguation needed) */
+  onDisambiguate?: (matches: FileNode[]) => void;
   /** Pre-fill input value (e.g. from command palette "Ask AI") */
   initialValue?: string;
   /** Auto-focus textarea on mount */
@@ -67,6 +73,9 @@ export const MessageInput = memo(function MessageInput({
   onFileItemsLoaded,
   fileSelected,
   externalFiles,
+  externalPaths,
+  onExternalPathsConsumed,
+  onDisambiguate,
   initialValue,
   autoFocus,
   permissionMode,
@@ -291,6 +300,17 @@ export const MessageInput = memo(function MessageInput({
     processFiles(externalFiles);
   }, [externalFiles]); // eslint-disable-line react-hooks/exhaustive-deps
 
+  // Handle external paths from file tree drag or disambiguation
+  useEffect(() => {
+    if (!externalPaths || externalPaths.length === 0) return;
+    const pathRefs = externalPaths.map((p) => `@${p}`).join(" ");
+    const cur = valueRef.current;
+    const sep = cur.length > 0 && !cur.endsWith(" ") ? " " : "";
+    writeTextareas(cur + sep + pathRefs + " ");
+    getVisibleTextarea()?.focus();
+    onExternalPathsConsumed?.();
+  }, [externalPaths]); // eslint-disable-line react-hooks/exhaustive-deps
+
   /** Upload a single file to the server, return server path */
   const uploadFile = useCallback(
     async (file: File): Promise<string | null> => {
@@ -318,12 +338,34 @@ export const MessageInput = memo(function MessageInput({
     [projectName],
   );
 
-  /** Process dropped/pasted/selected files */
+  /** Process dropped/pasted/selected files — resolves paths via server when possible */
   const processFiles = useCallback(
-    (files: File[]) => {
+    async (files: File[]) => {
       for (const file of files) {
+        // Step 1: Try server-side filename resolution for all files
+        if (projectName) {
+          try {
+            const data = await api.get<{ matches: FileNode[] }>(
+              `${projectUrl(projectName)}/files/resolve?name=${encodeURIComponent(file.name)}`,
+            );
+            if (data.matches.length === 1) {
+              const cur = valueRef.current;
+              const sep = cur.length > 0 && !cur.endsWith(" ") ? " " : "";
+              writeTextareas(cur + sep + `@${data.matches[0]!.path} `);
+              continue;
+            }
+            if (data.matches.length > 1) {
+              onDisambiguate?.(data.matches);
+              continue;
+            }
+            // 0 matches → fall through to existing behavior
+          } catch {
+            // Resolve failed → fall through
+          }
+        }
+
+        // Step 2: Fallback — upload supported files, insert name for unsupported
         if (!isSupportedFile(file)) {
-          // Unsupported → insert file name as text
           const cur = valueRef.current;
           const sep = cur.length > 0 && !cur.endsWith(" ") ? " " : "";
           writeTextareas(cur + sep + file.name);
@@ -358,7 +400,7 @@ export const MessageInput = memo(function MessageInput({
       }
       (mobileTextareaRef.current ?? textareaRef.current)?.focus();
     },
-    [uploadFile, writeTextareas],
+    [uploadFile, writeTextareas, projectName, onDisambiguate],
   );
 
   const removeAttachment = useCallback((id: string) => {
@@ -566,10 +608,19 @@ export const MessageInput = memo(function MessageInput({
   const handleDrop = useCallback(
     (e: DragEvent<HTMLTextAreaElement>) => {
       e.preventDefault();
+      // Check for internal file tree drag first
+      const ppmPath = e.dataTransfer.getData("application/x-ppm-path");
+      if (ppmPath) {
+        const cur = valueRef.current;
+        const sep = cur.length > 0 && !cur.endsWith(" ") ? " " : "";
+        writeTextareas(cur + sep + `@${ppmPath} `);
+        getVisibleTextarea()?.focus();
+        return;
+      }
       const files = Array.from(e.dataTransfer.files);
       if (files.length > 0) processFiles(files);
     },
-    [processFiles],
+    [processFiles, writeTextareas, getVisibleTextarea],
   );
 
   const handleDragOver = useCallback((e: DragEvent<HTMLTextAreaElement>) => {

package/src/web/components/explorer/file-tree.tsx

@@ -89,6 +89,13 @@ const TreeNode = memo(function TreeNode({ node, depth, projectName, onAction, on
     onFileOpen?.();
   }
 
+  function handleDragStart(e: React.DragEvent) {
+    const pathValue = isDir ? `${node.path}/` : node.path;
+    e.dataTransfer.setData("application/x-ppm-path", pathValue);
+    e.dataTransfer.setData("text/plain", node.name);
+    e.dataTransfer.effectAllowed = "copy";
+  }
+
   const Icon = isDir
     ? isExpanded
       ? FolderOpen
@@ -107,6 +114,8 @@ const TreeNode = memo(function TreeNode({ node, depth, projectName, onAction, on
       <ContextMenu>
         <ContextMenuTrigger asChild>
           <button
+            draggable
+            onDragStart={handleDragStart}
             onClick={handleClick}
             className={cn(
               "flex items-center w-full gap-1.5 px-2 py-1 rounded-sm text-sm",

package/src/web/components/extensions/extension-webview.tsx

@@ -34,6 +34,8 @@ export function ExtensionWebview({ metadata }: ExtensionWebviewProps) {
   // Prefer currentProject (reflects URL/active project) over stale tab metadata
   const projectName = currentProject || (metadata?.projectName as string | undefined) || undefined;
   const [timedOut, setTimedOut] = useState(false);
+  // Track whether extensions are activated (contributions received from WS)
+  const extensionsReady = useExtensionStore((s) => s.contributions !== null);
 
   // Match panel: prefer panelId (exact), fallback to viewType match (reload recovery)
   const panel = useExtensionStore((s) => {
@@ -59,11 +61,11 @@ export function ExtensionWebview({ metadata }: ExtensionWebviewProps) {
   const prevProjectRef = useRef<string | null>(null);
 
   // On reload: resolve project path and dispatch command once.
-  // No retry — if it fails, user closes tab and reopens to retry.
+  // Wait for extensions to be activated (contributions received) before dispatching.
   // Skip if project-sync effect already dispatched for this project
   // (panel is briefly undefined during dispose→recreate transition).
   useEffect(() => {
-    if (panel || !viewType) return;
+    if (panel || !viewType || !extensionsReady) return;
     // If we already dispatched for this project (via project-sync effect),
     // don't dispatch again — the panel is just temporarily missing.
     if (projectName && projectName === prevProjectRef.current) return;
@@ -88,10 +90,9 @@ export function ExtensionWebview({ metadata }: ExtensionWebviewProps) {
       }));
     }
 
-    // Short delay to let WS connect after page load
-    const timer = setTimeout(dispatch, 500);
-    return () => { cancelled = true; clearTimeout(timer); };
-  }, [panel, viewType, projectName]);
+    dispatch();
+    return () => { cancelled = true; };
+  }, [panel, viewType, projectName, extensionsReady]);
 
   // When panel exists, ensure correct project is loaded.
   // On mount: dispatch command so extension can reload if project differs.
@@ -165,12 +166,25 @@ export function ExtensionWebview({ metadata }: ExtensionWebviewProps) {
     };
   }, []);
 
-  // Timeout: if panel doesn't appear within 5s, show error
+  // Auto-retry: if panel doesn't appear after extensions are ready,
+  // re-dispatch the command every 2s (up to 3 times) before showing error.
+  // This handles transient WS instability during initial page load where the
+  // first command dispatch may be lost due to connection cycling.
   useEffect(() => {
     if (panel) { setTimedOut(false); return; }
-    const timer = setTimeout(() => setTimedOut(true), 5_000);
-    return () => clearTimeout(timer);
-  }, [panel]);
+    if (!extensionsReady || !viewType) return;
+    let retries = 0;
+    const id = setInterval(() => {
+      retries++;
+      if (retries > 3) {
+        clearInterval(id);
+        setTimedOut(true);
+        return;
+      }
+      handleRetry();
+    }, 2_000);
+    return () => clearInterval(id);
+  }, [panel, extensionsReady, viewType, handleRetry]);
 
   // Listen for postMessage from iframe → forward to extension via WS bridge
   useEffect(() => {

package/src/web/components/jira/jira-config-form.tsx

@@ -0,0 +1,109 @@
+import { useState, useEffect, type FormEvent } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { useJiraStore } from "@/stores/jira-store";
+import { CheckCircle, AlertCircle, Loader2, Trash2 } from "lucide-react";
+
+interface Props {
+  projectId: number;
+  existing?: { baseUrl: string; email: string; hasToken: boolean } | null;
+}
+
+export function JiraConfigForm({ projectId, existing }: Props) {
+  const { saveConfig, deleteConfig, testConnection } = useJiraStore();
+  const [baseUrl, setBaseUrl] = useState(existing?.baseUrl ?? "");
+  const [email, setEmail] = useState(existing?.email ?? "");
+  const [token, setToken] = useState("");
+
+  // Sync state when existing config loads or changes
+  useEffect(() => {
+    if (existing) {
+      setBaseUrl(existing.baseUrl);
+      setEmail(existing.email);
+    }
+  }, [existing?.baseUrl, existing?.email]);
+  const [saving, setSaving] = useState(false);
+  const [testing, setTesting] = useState(false);
+  const [testResult, setTestResult] = useState<"ok" | "fail" | null>(null);
+  const [testError, setTestError] = useState<string | null>(null);
+
+  const handleSave = async (e: FormEvent) => {
+    e.preventDefault();
+    if (!baseUrl || !email || (!token && !existing?.hasToken)) return;
+    setSaving(true);
+    try {
+      await saveConfig(projectId, { baseUrl, email, ...(token ? { token } : {}) });
+      setToken("");
+    } catch {}
+    setSaving(false);
+  };
+
+  const handleTest = async () => {
+    setTesting(true);
+    setTestResult(null);
+    setTestError(null);
+    try {
+      const ok = await testConnection(projectId);
+      setTestResult(ok ? "ok" : "fail");
+    } catch (e: any) {
+      setTestResult("fail");
+      setTestError(e?.message ?? "Connection failed");
+    }
+    setTesting(false);
+  };
+
+  return (
+    <form onSubmit={handleSave} className="space-y-3">
+      <div>
+        <label className="text-xs text-muted-foreground">Base URL</label>
+        <Input
+          value={baseUrl}
+          onChange={(e) => setBaseUrl(e.target.value)}
+          placeholder="https://mysite.atlassian.net"
+          className="h-9"
+        />
+      </div>
+      <div>
+        <label className="text-xs text-muted-foreground">Email</label>
+        <Input
+          value={email}
+          onChange={(e) => setEmail(e.target.value)}
+          placeholder="you@company.com"
+          className="h-9"
+        />
+      </div>
+      <div>
+        <label className="text-xs text-muted-foreground">
+          API Token {existing?.hasToken && <span className="text-green-500">(saved)</span>}
+        </label>
+        <Input
+          type="password"
+          value={token}
+          onChange={(e) => setToken(e.target.value)}
+          placeholder={existing?.hasToken ? "Enter new token to replace" : "Your Jira API token"}
+          className="h-9"
+        />
+      </div>
+      <div className="flex items-center gap-2 flex-wrap">
+        <Button type="submit" size="sm" disabled={saving} className="min-w-[44px] min-h-[44px]">
+          {saving ? <Loader2 className="size-4 animate-spin" /> : "Save"}
+        </Button>
+        {existing && (
+          <>
+            <Button type="button" size="sm" variant="outline" onClick={handleTest} disabled={testing} className="min-h-[44px]">
+              {testing ? <Loader2 className="size-4 animate-spin" /> : "Test Connection"}
+            </Button>
+            <Button type="button" size="sm" variant="destructive" onClick={() => deleteConfig(projectId)} className="min-h-[44px]">
+              <Trash2 className="size-4" />
+            </Button>
+          </>
+        )}
+        {testResult === "ok" && <CheckCircle className="size-4 text-green-500" />}
+        {testResult === "fail" && <AlertCircle className="size-4 text-red-500" />}
+      </div>
+      {testError && (
+        <p className="text-xs text-red-500 break-all">{testError}</p>
+      )}
+    </form>
+  );
+}

package/src/web/components/jira/jira-debug-prompt-dialog.tsx

@@ -0,0 +1,58 @@
+import { useState, useEffect } from "react";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { useJiraStore } from "@/stores/jira-store";
+import type { JiraWatchResult } from "../../../../src/types/jira";
+
+interface Props {
+  result: JiraWatchResult | null;
+  onClose: () => void;
+}
+
+export function JiraDebugPromptDialog({ result, onClose }: Props) {
+  const { watchers, startDebug } = useJiraStore();
+  const [prompt, setPrompt] = useState("");
+
+  useEffect(() => {
+    if (!result) return;
+    const watcher = watchers.find((w) => w.id === result.watcherId);
+    const template = watcher?.promptTemplate
+      ?? `Debug Jira issue {issue_key}: {summary}`;
+    setPrompt(
+      template
+        .replace(/\{issue_key\}/g, result.issueKey)
+        .replace(/\{summary\}/g, result.issueSummary ?? ""),
+    );
+  }, [result, watchers]);
+
+  const handleStart = async () => {
+    if (!result) return;
+    try {
+      await startDebug(result.id, prompt);
+    } catch {}
+    onClose();
+  };
+
+  return (
+    <Dialog open={!!result} onOpenChange={(open) => { if (!open) onClose(); }}>
+      <DialogContent className="max-w-md">
+        <DialogHeader>
+          <DialogTitle>Start Debug: {result?.issueKey}</DialogTitle>
+        </DialogHeader>
+        <p className="text-sm text-muted-foreground">{result?.issueSummary}</p>
+        <div>
+          <label className="text-xs text-muted-foreground">Debug Prompt</label>
+          <textarea
+            value={prompt}
+            onChange={(e) => setPrompt(e.target.value)}
+            className="w-full h-24 rounded-md border border-input bg-background px-3 py-2 text-xs font-mono resize-none mt-1"
+            placeholder="Debug Jira issue {issue_key}: {summary}"
+          />
+        </div>
+        <Button size="sm" className="w-full min-h-[44px]" onClick={handleStart}>
+          Start Debug Session
+        </Button>
+      </DialogContent>
+    </Dialog>
+  );
+}