@mndrk/agx 2.0.22 → 2.0.24

package/cloud-runtime/standalone/fix-primary.js

@@ -0,0 +1,30 @@
+const fs = require('fs');
+
+const filesToFix = [
+  'components/chat-ui/ThreadMentionPopover.tsx',
+  'components/chat-ui/CommandPopover.tsx',
+  'components/chat-ui/FileMentionPopoverItem.tsx'
+];
+
+for (const file of filesToFix) {
+  try {
+    let content = fs.readFileSync(file, 'utf8');
+    
+    content = content.replace(/\bbg-indigo-50\b/g, 'bg-[var(--primary-muted)]');
+    content = content.replace(/\bbg-indigo-100\b/g, 'bg-[var(--primary-muted)]');
+    content = content.replace(/\btext-indigo-600\b/g, 'text-[var(--primary)]');
+    content = content.replace(/\btext-indigo-900\b/g, 'text-[var(--primary)]');
+    
+    content = content.replace(/\bbg-blue-50\b/g, 'bg-[var(--primary-muted)]');
+    content = content.replace(/\bbg-blue-100\b/g, 'bg-[var(--primary-muted)]');
+    content = content.replace(/\btext-blue-600\b/g, 'text-[var(--primary)]');
+    content = content.replace(/\btext-blue-900\b/g, 'text-[var(--primary)]');
+    content = content.replace(/\btext-blue-500\b/g, 'text-[var(--primary)]');
+    
+    fs.writeFileSync(file, content, 'utf8');
+  } catch (err) {
+    console.error(`Error processing ${file}:`, err.message);
+  }
+}
+
+console.log("Updated popover selection states.");

package/cloud-runtime/standalone/fix-theme.js

@@ -0,0 +1,78 @@
+const fs = require('fs');
+const path = require('path');
+
+function getAllFiles(dirPath, arrayOfFiles) {
+  const files = fs.readdirSync(dirPath);
+  arrayOfFiles = arrayOfFiles || [];
+  files.forEach(function(file) {
+    if (fs.statSync(dirPath + "/" + file).isDirectory()) {
+      arrayOfFiles = getAllFiles(dirPath + "/" + file, arrayOfFiles);
+    } else {
+      if (file.endsWith('.tsx') || file.endsWith('.ts')) {
+        arrayOfFiles.push(path.join(dirPath, file));
+      }
+    }
+  });
+  return arrayOfFiles;
+}
+
+let allFiles = [];
+try { allFiles.push(...getAllFiles('app/agents')); } catch (e) {}
+try { allFiles.push(...getAllFiles('components')); } catch (e) {}
+
+const replacements = [
+  { regex: /\bbg-white\/80\b/g, replace: 'bg-[var(--card-bg)]/80' },
+  { regex: /\bbg-white\b/g, replace: 'bg-[var(--card-bg)]' },
+  { regex: /\bbg-\[#F8FAFC\]\b/g, replace: 'bg-[var(--background)]' },
+  { regex: /\bbg-slate-50\b/g, replace: 'bg-[var(--app-shell-subtle)]' },
+  { regex: /\bbg-slate-100\b/g, replace: 'bg-[var(--muted)]' },
+  { regex: /\bbg-slate-200\b/g, replace: 'bg-[var(--muted)]' },
+  { regex: /\bbg-zinc-50\b/g, replace: 'bg-[var(--app-shell-subtle)]' },
+  { regex: /\bbg-zinc-100\b/g, replace: 'bg-[var(--muted)]' },
+  
+  { regex: /\btext-slate-900\b/g, replace: 'text-[var(--foreground)]' },
+  { regex: /\btext-slate-800\b/g, replace: 'text-[var(--foreground)]' },
+  { regex: /\btext-slate-700\b/g, replace: 'text-[var(--foreground)]' },
+  { regex: /\btext-slate-600\b/g, replace: 'text-[var(--muted-foreground)]' },
+  { regex: /\btext-slate-500\b/g, replace: 'text-[var(--muted-foreground)]' },
+  { regex: /\btext-slate-400\b/g, replace: 'text-[var(--muted-foreground)]' },
+  { regex: /\btext-slate-300\b/g, replace: 'text-[var(--muted-foreground)]' },
+  
+  { regex: /\btext-zinc-900\b/g, replace: 'text-[var(--foreground)]' },
+  { regex: /\btext-zinc-800\b/g, replace: 'text-[var(--foreground)]' },
+  { regex: /\btext-zinc-700\b/g, replace: 'text-[var(--foreground)]' },
+  { regex: /\btext-zinc-600\b/g, replace: 'text-[var(--muted-foreground)]' },
+  { regex: /\btext-zinc-500\b/g, replace: 'text-[var(--muted-foreground)]' },
+  { regex: /\btext-zinc-400\b/g, replace: 'text-[var(--muted-foreground)]' },
+  
+  { regex: /\bborder-slate-100\b/g, replace: 'border-[var(--border)]' },
+  { regex: /\bborder-slate-200\b/g, replace: 'border-[var(--border)]' },
+  { regex: /\bborder-slate-300\b/g, replace: 'border-[var(--border)]' },
+  { regex: /\bborder-zinc-100\b/g, replace: 'border-[var(--border)]' },
+  { regex: /\bborder-zinc-200\b/g, replace: 'border-[var(--border)]' },
+  
+  { regex: /\bshadow-slate-200\/50\b/g, replace: 'shadow-black/5' },
+  { regex: /\bshadow-slate-200\b/g, replace: 'shadow-black/5' }
+];
+
+let changedFiles = 0;
+
+for (const file of allFiles) {
+  try {
+    let content = fs.readFileSync(file, 'utf8');
+    let original = content;
+    
+    for (const { regex, replace } of replacements) {
+      content = content.replace(regex, replace);
+    }
+    
+    if (content !== original) {
+      fs.writeFileSync(file, content, 'utf8');
+      changedFiles++;
+    }
+  } catch (err) {
+    console.error(`Error processing ${file}:`, err.message);
+  }
+}
+
+console.log(`Updated ${changedFiles} files with semantic variables.`);

package/cloud-runtime/standalone/hooks/useKeyboardShortcuts.ts

@@ -0,0 +1,131 @@
+"use client";
+
+import { useEffect, useCallback } from "react";
+
+export interface KeyboardShortcut {
+  key: string;
+  metaKey?: boolean;
+  ctrlKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  action: () => void;
+  description?: string;
+}
+
+/**
+ * Hook for registering global keyboard shortcuts.
+ * Handles platform differences (Cmd on Mac, Ctrl on Windows/Linux).
+ *
+ * @example
+ * useKeyboardShortcuts([
+ *   { key: 'n', metaKey: true, action: () => createNewThread(), description: 'New thread' },
+ *   { key: 'k', metaKey: true, action: () => openSearch(), description: 'Search' },
+ * ]);
+ */
+export function useKeyboardShortcuts(shortcuts: KeyboardShortcut[]) {
+  const handleKeyDown = useCallback(
+    (event: KeyboardEvent) => {
+      // Don't trigger shortcuts when typing in inputs
+      const target = event.target as HTMLElement;
+      if (
+        target.tagName === "INPUT" ||
+        target.tagName === "TEXTAREA" ||
+        target.isContentEditable
+      ) {
+        // Allow Escape to pass through
+        if (event.key !== "Escape") {
+          return;
+        }
+      }
+
+      const isMac = typeof navigator !== "undefined" && /Mac/.test(navigator.platform);
+      const cmdKey = isMac ? event.metaKey : event.ctrlKey;
+
+      for (const shortcut of shortcuts) {
+        const keyMatch = event.key.toLowerCase() === shortcut.key.toLowerCase();
+        const metaMatch = shortcut.metaKey ? cmdKey : true;
+        const ctrlMatch = shortcut.ctrlKey ? event.ctrlKey : true;
+        const shiftMatch = shortcut.shiftKey ? event.shiftKey : true;
+        const altMatch = shortcut.altKey ? event.altKey : true;
+
+        // If metaKey is specified, we don't require ctrlKey (and vice versa on non-Mac)
+        const shouldMatchCtrl = shortcut.ctrlKey && !shortcut.metaKey;
+        const ctrlOk = shouldMatchCtrl ? event.ctrlKey : true;
+
+        if (keyMatch && metaMatch && ctrlOk && shiftMatch && altMatch) {
+          // For meta shortcuts, ensure we're not just pressing the key without modifier
+          if (shortcut.metaKey && !cmdKey) continue;
+          if (shortcut.ctrlKey && !event.ctrlKey) continue;
+
+          event.preventDefault();
+          shortcut.action();
+          return;
+        }
+      }
+    },
+    [shortcuts]
+  );
+
+  useEffect(() => {
+    window.addEventListener("keydown", handleKeyDown);
+    return () => {
+      window.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [handleKeyDown]);
+}
+
+/**
+ * Common keyboard shortcuts for the app.
+ * Use these constants for consistency across the app.
+ */
+export const SHORTCUTS = {
+  NEW_THREAD: { key: "n", metaKey: true, description: "New thread" },
+  SEARCH: { key: "k", metaKey: true, description: "Search" },
+  CLOSE: { key: "w", metaKey: true, description: "Close" },
+  ESCAPE: { key: "Escape", description: "Escape / Cancel" },
+  SIDEBAR_TOGGLE: { key: "b", metaKey: true, description: "Toggle sidebar" },
+  LOG_PANEL_TOGGLE: { key: "l", metaKey: true, description: "Toggle logs" },
+  REFRESH: { key: "r", metaKey: true, description: "Refresh" },
+} as const;
+
+/**
+ * Hook for using predefined shortcuts with custom actions.
+ *
+ * @example
+ * useAppShortcuts({
+ *   newThread: () => createNewThread(),
+ *   search: () => openSearch(),
+ *   escape: () => closeModal(),
+ * });
+ */
+export function useAppShortcuts(actions: {
+  newThread?: () => void;
+  search?: () => void;
+  close?: () => void;
+  escape?: () => void;
+  sidebarToggle?: () => void;
+  logPanelToggle?: () => void;
+}) {
+  const shortcuts: KeyboardShortcut[] = [];
+
+  if (actions.newThread) {
+    shortcuts.push({ ...SHORTCUTS.NEW_THREAD, action: actions.newThread });
+  }
+  if (actions.search) {
+    shortcuts.push({ ...SHORTCUTS.SEARCH, action: actions.search });
+  }
+  if (actions.close) {
+    shortcuts.push({ ...SHORTCUTS.CLOSE, action: actions.close });
+  }
+  if (actions.escape) {
+    shortcuts.push({ ...SHORTCUTS.ESCAPE, action: actions.escape });
+  }
+  if (actions.sidebarToggle) {
+    shortcuts.push({ ...SHORTCUTS.SIDEBAR_TOGGLE, action: actions.sidebarToggle });
+  }
+  if (actions.logPanelToggle) {
+    shortcuts.push({ ...SHORTCUTS.LOG_PANEL_TOGGLE, action: actions.logPanelToggle });
+  }
+
+  useKeyboardShortcuts(shortcuts);
+}

package/cloud-runtime/standalone/lib/history-store.ts

@@ -369,6 +369,11 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
     migrateReactionHostPidColumn(db);
     // Rename thread_status "parked" → "in-review"
     db.exec("UPDATE messages SET thread_status = 'in-review' WHERE thread_status = 'parked'");
+    // Rename thread_status "thinking" → "active", "resolved" → "done"
+    db.exec("UPDATE messages SET thread_status = 'active' WHERE thread_status = 'thinking'");
+    db.exec("UPDATE messages SET thread_status = 'done' WHERE thread_status = 'resolved'");
+    // Remove "converged" status — migrate to "active"
+    db.exec("UPDATE messages SET thread_status = 'active' WHERE thread_status = 'converged'");
     migrateAgentProcessesAddId(db);
     initializeMessageSearch(db);
     db.exec(`
@@ -520,7 +525,7 @@ export async function listRootMessages(options?: {
     ];
     const params: unknown[] = [];
     if (status) {
-      where.push("COALESCE(m.thread_status, 'thinking') = ?");
+      where.push("COALESCE(m.thread_status, 'active') = ?");
       params.push(status);
     }
     const whereClause = where.join(" AND ");

package/cloud-runtime/standalone/lib/storage/thread-adapter.ts

@@ -3,7 +3,7 @@ import type { GroupMessage } from "../types";
 /**
  * Lifecycle status for a conversation thread.
  */
-export type ThreadStatus = "thinking" | "converged" | "resolved" | "in-review" | "archived" | "paused";
+export type ThreadStatus = "active" | "paused" | "in-review" | "done" | "archived";
 
 /**
  * Arbitrary metadata that can be stored alongside a thread for sorting/filtering.
@@ -26,9 +26,9 @@ export interface Thread {
   updatedAt: number;
   /** Optional metadata bucket adapters can use for sorting/filtering. */
   metadata?: ThreadMetadata;
-  /** Lifecycle status of the thread. Defaults to "thinking". */
+  /** Lifecycle status of the thread. Defaults to "active". */
   status?: ThreadStatus;
-  /** Free-text outcome note for converged threads. */
+  /** Free-text outcome note. */
   outcomeNote?: string;
   /** Optional project assignment for routing. */
   projectId?: string | null;

package/cloud-runtime/standalone/state/windowState.ts

@@ -0,0 +1,179 @@
+/**
+ * Window state persistence for native desktop feel.
+ * Persists window bounds, sidebar widths, and scroll positions across sessions.
+ */
+
+const WINDOW_STATE_KEY = "agx:windowState";
+
+export interface WindowBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  isMaximized: boolean;
+}
+
+export interface SidebarState {
+  workspaceWidth: number;
+  logPanelHeight: number;
+  workspaceVisible: boolean;
+  logPanelVisible: boolean;
+}
+
+export interface ScrollState {
+  lastThreadId: string | null;
+  lastWorkspaceId: string | null;
+}
+
+export interface WindowState {
+  bounds: WindowBounds | null;
+  sidebar: SidebarState;
+  scroll: ScrollState;
+}
+
+const DEFAULT_SIDEBAR: SidebarState = {
+  workspaceWidth: 260,
+  logPanelHeight: 200,
+  workspaceVisible: true,
+  logPanelVisible: false,
+};
+
+const DEFAULT_SCROLL: ScrollState = {
+  lastThreadId: null,
+  lastWorkspaceId: null,
+};
+
+const DEFAULT_WINDOW_STATE: WindowState = {
+  bounds: null,
+  sidebar: DEFAULT_SIDEBAR,
+  scroll: DEFAULT_SCROLL,
+};
+
+function isStorageAvailable(): boolean {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+
+function readWindowState(): WindowState {
+  if (!isStorageAvailable()) {
+    return { ...DEFAULT_WINDOW_STATE };
+  }
+
+  const raw = window.localStorage.getItem(WINDOW_STATE_KEY);
+  if (!raw) {
+    return { ...DEFAULT_WINDOW_STATE };
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<WindowState>;
+    return {
+      bounds: parsed.bounds || null,
+      sidebar: {
+        ...DEFAULT_SIDEBAR,
+        ...(parsed.sidebar || {}),
+      },
+      scroll: {
+        ...DEFAULT_SCROLL,
+        ...(parsed.scroll || {}),
+      },
+    };
+  } catch {
+    return { ...DEFAULT_WINDOW_STATE };
+  }
+}
+
+function writeWindowState(state: WindowState): void {
+  if (!isStorageAvailable()) return;
+
+  try {
+    window.localStorage.setItem(WINDOW_STATE_KEY, JSON.stringify(state));
+  } catch {
+    // ignore storage errors
+  }
+}
+
+// Window bounds
+export function loadWindowBounds(): WindowBounds | null {
+  return readWindowState().bounds;
+}
+
+export function persistWindowBounds(bounds: WindowBounds): void {
+  const state = readWindowState();
+  state.bounds = bounds;
+  writeWindowState(state);
+}
+
+// Sidebar state
+export function loadSidebarState(): SidebarState {
+  return readWindowState().sidebar;
+}
+
+export function persistSidebarState(sidebar: Partial<SidebarState>): void {
+  const state = readWindowState();
+  state.sidebar = { ...state.sidebar, ...sidebar };
+  writeWindowState(state);
+}
+
+export function loadWorkspaceWidth(): number {
+  return loadSidebarState().workspaceWidth;
+}
+
+export function persistWorkspaceWidth(width: number): void {
+  persistSidebarState({ workspaceWidth: width });
+}
+
+export function loadLogPanelHeight(): number {
+  return loadSidebarState().logPanelHeight;
+}
+
+export function persistLogPanelHeight(height: number): void {
+  persistSidebarState({ logPanelHeight: height });
+}
+
+export function loadWorkspaceVisible(): boolean {
+  return loadSidebarState().workspaceVisible;
+}
+
+export function persistWorkspaceVisible(visible: boolean): void {
+  persistSidebarState({ workspaceVisible: visible });
+}
+
+export function loadLogPanelVisible(): boolean {
+  return loadSidebarState().logPanelVisible;
+}
+
+export function persistLogPanelVisible(visible: boolean): void {
+  persistSidebarState({ logPanelVisible: visible });
+}
+
+// Scroll/navigation state
+export function loadScrollState(): ScrollState {
+  return readWindowState().scroll;
+}
+
+export function persistScrollState(scroll: Partial<ScrollState>): void {
+  const state = readWindowState();
+  state.scroll = { ...state.scroll, ...scroll };
+  writeWindowState(state);
+}
+
+export function loadLastThreadId(): string | null {
+  return loadScrollState().lastThreadId;
+}
+
+export function persistLastThreadId(threadId: string | null): void {
+  persistScrollState({ lastThreadId: threadId });
+}
+
+export function loadLastWorkspaceId(): string | null {
+  return loadScrollState().lastWorkspaceId;
+}
+
+export function persistLastWorkspaceId(workspaceId: string | null): void {
+  persistScrollState({ lastWorkspaceId: workspaceId });
+}
+
+// Clear all window state (for logout/reset)
+export function clearWindowState(): void {
+  if (!isStorageAvailable()) return;
+  window.localStorage.removeItem(WINDOW_STATE_KEY);
+}