@dyyz1993/create-agent 1.9.0

package/templates/agent/src/mainview/stores/use-git-store.ts

@@ -0,0 +1,291 @@
+import { create } from "zustand";
+import { apiClient } from "../lib/api-client";
+import { rpcCache } from "../lib/rpc-cache";
+import { useLogStore } from "./use-log-store";
+
+export interface GitFileChange {
+  path: string;
+  status: "modified" | "added" | "deleted" | "renamed" | "copied";
+}
+
+export interface GitCommit {
+  hash: string;
+  shortHash: string;
+  message: string;
+  author: string;
+  date: string;
+}
+
+export interface GitBranch {
+  name: string;
+  isCurrent: boolean;
+  isRemote: boolean;
+}
+
+export interface GitWorktree {
+  path: string;
+  branch: string;
+  isMain: boolean;
+}
+
+interface GitState {
+  branch: string;
+  ahead: number;
+  behind: number;
+  staged: GitFileChange[];
+  changed: GitFileChange[];
+  untracked: string[];
+  commits: GitCommit[];
+  loadingCommits: boolean;
+  currentDiff: { filePath: string; diff: string; oldContent: string; newContent: string } | null;
+  loadingDiff: boolean;
+  expandedCommits: Set<string>;
+  commitFiles: Record<string, GitFileChange[]>;
+  loadingCommitFiles: Set<string>;
+  branches: GitBranch[];
+  loadingBranches: boolean;
+  worktrees: GitWorktree[];
+  loadingAction: string | null;
+
+  fetchStatus: (repoPath: string) => Promise<void>;
+  fetchDiff: (repoPath: string, filePath: string, staged?: boolean) => Promise<void>;
+  fetchLog: (repoPath: string) => Promise<void>;
+  clearDiff: () => void;
+  toggleCommitExpand: (repoPath: string, hash: string) => Promise<void>;
+  fetchCommitFileDiff: (repoPath: string, hash: string, filePath: string) => Promise<void>;
+  fetchBranches: (repoPath: string) => Promise<void>;
+  checkout: (repoPath: string, branch: string) => Promise<void>;
+  stageFiles: (repoPath: string, paths: string[]) => Promise<void>;
+  unstageFiles: (repoPath: string, paths: string[]) => Promise<void>;
+  commit: (repoPath: string, message: string) => Promise<void>;
+  push: (repoPath: string) => Promise<void>;
+  pull: (repoPath: string) => Promise<void>;
+  fetchWorktrees: (repoPath: string) => Promise<void>;
+  refresh: (repoPath: string) => Promise<void>;
+}
+
+export const useGitStore = create<GitState>((set, get) => ({
+  branch: "",
+  ahead: 0,
+  behind: 0,
+  staged: [],
+  changed: [],
+  untracked: [],
+  commits: [],
+  loadingCommits: false,
+  currentDiff: null,
+  loadingDiff: false,
+  expandedCommits: new Set(),
+  commitFiles: {},
+  loadingCommitFiles: new Set(),
+  branches: [],
+  loadingBranches: false,
+  worktrees: [],
+  loadingAction: null,
+
+  refresh: async (repoPath) => {
+    await get().fetchStatus(repoPath);
+  },
+
+  fetchStatus: async (repoPath) => {
+    const addLog = useLogStore.getState().addLog;
+    try {
+      const res = await apiClient.call("git.status", { repoPath });
+      set({
+        branch: res.branch,
+        ahead: res.ahead,
+        behind: res.behind,
+        staged: res.staged,
+        changed: res.changed,
+        untracked: res.untracked,
+      });
+    } catch (err) {
+      addLog(`Git status error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  fetchDiff: async (repoPath, filePath, staged) => {
+    const addLog = useLogStore.getState().addLog;
+    addLog(`Git diff: ${filePath}`);
+    set({ loadingDiff: true });
+    try {
+      const res = await apiClient.call("git.diff", { repoPath, filePath, staged });
+      addLog(`Git diff result: ${res.diff.length} chars`);
+      set({ currentDiff: res, loadingDiff: false });
+    } catch (err) {
+      addLog(`Git diff error: ${err instanceof Error ? err.message : String(err)}`);
+      set({ loadingDiff: false });
+    }
+  },
+
+  fetchLog: async (repoPath) => {
+    set({ loadingCommits: true });
+    try {
+      const res = await apiClient.call("git.log", { repoPath, maxCount: 50 });
+      set({ commits: res.commits, loadingCommits: false });
+    } catch (err) {
+      const addLog = useLogStore.getState().addLog;
+      addLog(`Git log error: ${err instanceof Error ? err.message : String(err)}`);
+      set({ loadingCommits: false });
+    }
+  },
+
+  clearDiff: () => set({ currentDiff: null }),
+
+  toggleCommitExpand: async (repoPath, hash) => {
+    const { expandedCommits, commitFiles } = get();
+    const next = new Set(expandedCommits);
+
+    if (next.has(hash)) {
+      next.delete(hash);
+      set({ expandedCommits: next });
+      return;
+    }
+
+    next.add(hash);
+    set({ expandedCommits: next });
+
+    if (!commitFiles[hash]) {
+      const loading = new Set(get().loadingCommitFiles);
+      loading.add(hash);
+      set({ loadingCommitFiles: loading });
+
+      try {
+        const res = await apiClient.call("git.commitFiles", { repoPath, hash });
+        set({ commitFiles: { ...get().commitFiles, [hash]: res.files } });
+      } catch (err) {
+        const addLog = useLogStore.getState().addLog;
+        addLog(`Git commitFiles error: ${err instanceof Error ? err.message : String(err)}`);
+      } finally {
+        const loading = new Set(get().loadingCommitFiles);
+        loading.delete(hash);
+        set({ loadingCommitFiles: loading });
+      }
+    }
+  },
+
+  fetchCommitFileDiff: async (repoPath, hash, filePath) => {
+    const addLog = useLogStore.getState().addLog;
+    addLog(`Git commit diff: ${hash.slice(0, 7)} ${filePath}`);
+    set({ loadingDiff: true });
+    try {
+      const res = await apiClient.call("git.commitFileDiff", { repoPath, hash, filePath });
+      set({ currentDiff: res, loadingDiff: false });
+    } catch (err) {
+      addLog(`Git commitFileDiff error: ${err instanceof Error ? err.message : String(err)}`);
+      set({ loadingDiff: false });
+    }
+  },
+
+  fetchBranches: async (repoPath) => {
+    set({ loadingBranches: true });
+    try {
+      const res = await apiClient.call("git.branches", { repoPath });
+      set({ branches: res.branches, loadingBranches: false });
+    } catch (err) {
+      const addLog = useLogStore.getState().addLog;
+      addLog(`Git branches error: ${err instanceof Error ? err.message : String(err)}`);
+      set({ loadingBranches: false });
+    }
+  },
+
+  checkout: async (repoPath, branch) => {
+    const addLog = useLogStore.getState().addLog;
+    set({ loadingAction: "checkout" });
+    try {
+      await apiClient.call("git.checkout", { repoPath, branch });
+      rpcCache.invalidateAll(["git.status", "git.branches", "git.log", "git.diff"]);
+      addLog(`Checked out: ${branch}`);
+      await get().refresh(repoPath);
+    } catch (err) {
+      addLog(`Git checkout error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      set({ loadingAction: null });
+    }
+  },
+
+  stageFiles: async (repoPath, paths) => {
+    const addLog = useLogStore.getState().addLog;
+    set({ loadingAction: "stage" });
+    try {
+      await apiClient.call("git.add", { repoPath, paths });
+      rpcCache.invalidateAll(["git.status", "git.diff"]);
+      addLog(`Staged: ${paths.join(", ")}`);
+      await get().refresh(repoPath);
+    } catch (err) {
+      addLog(`Git add error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      set({ loadingAction: null });
+    }
+  },
+
+  unstageFiles: async (repoPath, paths) => {
+    const addLog = useLogStore.getState().addLog;
+    set({ loadingAction: "unstage" });
+    try {
+      await apiClient.call("git.reset", { repoPath, paths });
+      rpcCache.invalidateAll(["git.status", "git.diff"]);
+      addLog(`Unstaged: ${paths.join(", ")}`);
+      await get().refresh(repoPath);
+    } catch (err) {
+      addLog(`Git reset error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      set({ loadingAction: null });
+    }
+  },
+
+  commit: async (repoPath, message) => {
+    const addLog = useLogStore.getState().addLog;
+    set({ loadingAction: "commit" });
+    try {
+      const res = await apiClient.call("git.commit", { repoPath, message });
+      rpcCache.invalidateAll(["git.status", "git.log", "git.diff"]);
+      addLog(`Committed: ${res.shortHash}`);
+      await get().refresh(repoPath);
+    } catch (err) {
+      addLog(`Git commit error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      set({ loadingAction: null });
+    }
+  },
+
+  push: async (repoPath) => {
+    const addLog = useLogStore.getState().addLog;
+    set({ loadingAction: "push" });
+    try {
+      await apiClient.call("git.push", { repoPath });
+      rpcCache.invalidateAll(["git.status", "git.log"]);
+      addLog("Pushed successfully");
+      await get().refresh(repoPath);
+    } catch (err) {
+      addLog(`Git push error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      set({ loadingAction: null });
+    }
+  },
+
+  pull: async (repoPath) => {
+    const addLog = useLogStore.getState().addLog;
+    set({ loadingAction: "pull" });
+    try {
+      await apiClient.call("git.pull", { repoPath });
+      rpcCache.invalidateAll(["git.status", "git.log", "git.diff"]);
+      addLog("Pulled successfully");
+      await get().refresh(repoPath);
+    } catch (err) {
+      addLog(`Git pull error: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      set({ loadingAction: null });
+    }
+  },
+
+  fetchWorktrees: async (repoPath) => {
+    try {
+      const res = await apiClient.call("git.worktreeList", { repoPath });
+      set({ worktrees: res.worktrees });
+    } catch (err) {
+      const addLog = useLogStore.getState().addLog;
+      addLog(`Git worktreeList error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+}));

package/templates/agent/src/mainview/stores/use-locale-store.ts

@@ -0,0 +1,27 @@
+import { create } from "zustand";
+import type { Locale } from "../lib/i18n";
+
+interface LocaleState {
+  locale: Locale;
+  setLocale: (locale: Locale) => void;
+}
+
+function getInitialLocale(): Locale {
+  if (typeof window === "undefined") return "en";
+  const stored = localStorage.getItem("locale");
+  if (stored === "en" || stored === "zh") return stored;
+  const browserLang = navigator.language.toLowerCase();
+  if (browserLang.startsWith("zh")) return "zh";
+  return "en";
+}
+
+export const useLocaleStore = create<LocaleState>((set) => ({
+  locale: getInitialLocale(),
+  setLocale: (locale) => {
+    localStorage.setItem("locale", locale);
+    import("../lib/i18n").then((i18n) => {
+      i18n.default.changeLanguage(locale);
+    });
+    set({ locale });
+  },
+}));

package/templates/agent/src/mainview/stores/use-log-store.ts

@@ -0,0 +1,16 @@
+import { create } from "zustand";
+
+interface LogState {
+  logs: string[];
+  addLog: (message: string) => void;
+}
+
+const MAX_LOGS = 100;
+
+export const useLogStore = create<LogState>((set) => ({
+  logs: [],
+  addLog: (message) =>
+    set((state) => ({
+      logs: [...state.logs.slice(-(MAX_LOGS - 1)), `[${new Date().toISOString().slice(11, 19)}] ${message}`],
+    })),
+}));

package/templates/agent/src/mainview/stores/use-notification-store.ts

@@ -0,0 +1,82 @@
+import { create } from "zustand";
+
+export type NotificationLevel = "info" | "warning" | "error";
+
+export interface AppNotification {
+  id: string;
+  message: string;
+  level: NotificationLevel;
+  timestamp: number;
+  sessionId?: string;
+  read: boolean;
+}
+
+interface NotificationState {
+  notifications: AppNotification[];
+  panelOpen: boolean;
+
+  push: (n: Omit<AppNotification, "id" | "timestamp" | "read">) => void;
+  markRead: (id: string) => void;
+  markAllRead: () => void;
+  dismiss: (id: string) => void;
+  clearAll: () => void;
+  togglePanel: () => void;
+  setPanelOpen: (open: boolean) => void;
+}
+
+export const useNotificationStore = create<NotificationState>((set) => ({
+  notifications: [],
+  panelOpen: false,
+
+  push(n) {
+    const entry: AppNotification = {
+      ...n,
+      id: `notif-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      timestamp: Date.now(),
+      read: false,
+    };
+    set((s) => ({
+      notifications: [entry, ...s.notifications],
+    }));
+
+    if (n.level === "info") {
+      setTimeout(() => {
+        set((s) => ({
+          notifications: s.notifications.filter((x) => x.id !== entry.id),
+        }));
+      }, 5000);
+    }
+  },
+
+  markRead(id) {
+    set((s) => ({
+      notifications: s.notifications.map((n) =>
+        n.id === id ? { ...n, read: true } : n,
+      ),
+    }));
+  },
+
+  markAllRead() {
+    set((s) => ({
+      notifications: s.notifications.map((n) => ({ ...n, read: true })),
+    }));
+  },
+
+  dismiss(id) {
+    set((s) => ({
+      notifications: s.notifications.filter((n) => n.id !== id),
+    }));
+  },
+
+  clearAll() {
+    set({ notifications: [] });
+  },
+
+  togglePanel() {
+    set((s) => ({ panelOpen: !s.panelOpen }));
+  },
+
+  setPanelOpen(open) {
+    set({ panelOpen: open });
+  },
+}));

package/templates/agent/src/mainview/stores/use-rules-store.ts

@@ -0,0 +1,54 @@
+import { create } from "zustand";
+import { apiClient } from "../lib/api-client";
+import { useLogStore } from "./use-log-store";
+import type { Rule } from "../../shared/modules/rules";
+
+interface RulesState {
+  rules: Rule[];
+  fetchRules: () => Promise<void>;
+  addRule: (name: string, pattern: string) => Promise<void>;
+  toggleRule: (id: string) => Promise<void>;
+  removeRule: (id: string) => Promise<void>;
+}
+
+export const useRulesStore = create<RulesState>((set) => ({
+  rules: [],
+
+  fetchRules: async () => {
+    try {
+      const result = await apiClient.call("rules.list", {});
+      set({ rules: result.rules });
+    } catch (err) {
+      useLogStore.getState().addLog(`Rules fetch error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  addRule: async (name, pattern) => {
+    try {
+      const result = await apiClient.call("rules.add", { name, pattern });
+      set((s) => ({ rules: [...s.rules, result.rule] }));
+    } catch (err) {
+      useLogStore.getState().addLog(`Rules add error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  toggleRule: async (id) => {
+    try {
+      const result = await apiClient.call("rules.toggle", { id });
+      set((s) => ({
+        rules: s.rules.map((r) => (r.id === id ? result.rule : r)),
+      }));
+    } catch (err) {
+      useLogStore.getState().addLog(`Rules toggle error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  removeRule: async (id) => {
+    try {
+      await apiClient.call("rules.remove", { id });
+      set((s) => ({ rules: s.rules.filter((r) => r.id !== id) }));
+    } catch (err) {
+      useLogStore.getState().addLog(`Rules remove error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+}));

package/templates/agent/src/mainview/stores/use-sidebar-store.ts

@@ -0,0 +1,99 @@
+import { create } from "zustand";
+
+export type SidebarPanelId = "explorer" | "git" | "search" | "rules";
+export type Breakpoint = "mobile" | "tablet" | "desktop";
+
+const PINNED_KEY = "sidebar-pinned";
+const WIDTH_KEY = "sidebar-width";
+export const SIDEBAR_MIN_WIDTH = 180;
+export const SIDEBAR_MAX_WIDTH = 480;
+const DEFAULT_WIDTH = 240;
+
+function getBreakpoint(width: number): Breakpoint {
+  if (width < 768) return "mobile";
+  if (width < 1024) return "tablet";
+  return "desktop";
+}
+
+interface SidebarState {
+  activePanel: SidebarPanelId | null;
+  isPinned: boolean;
+  drawerOpen: boolean;
+  sidebarWidth: number;
+  breakpoint: Breakpoint;
+  togglePanel: (id: SidebarPanelId) => void;
+  setActivePanel: (id: SidebarPanelId | null) => void;
+  setPinned: (pinned: boolean) => void;
+  setDrawerOpen: (open: boolean) => void;
+  setSidebarWidth: (width: number) => void;
+  _setBreakpoint: (bp: Breakpoint) => void;
+}
+
+function readPinned(): boolean {
+  try {
+    const stored = localStorage.getItem(PINNED_KEY);
+    if (stored !== null) return stored !== "false";
+    // 首次加载：desktop 默认 pinned，tablet/mobile 默认 drawer
+    return window.innerWidth >= 1024;
+  } catch {
+    return true;
+  }
+}
+
+function readWidth(): number {
+  try {
+    const v = Number(localStorage.getItem(WIDTH_KEY));
+    if (Number.isNaN(v) || v < SIDEBAR_MIN_WIDTH || v > SIDEBAR_MAX_WIDTH) return DEFAULT_WIDTH;
+    return v;
+  } catch {
+    return DEFAULT_WIDTH;
+  }
+}
+
+const initialWidth = typeof window !== "undefined" ? window.innerWidth : 1024;
+
+export const useSidebarStore = create<SidebarState>((set, get) => ({
+  activePanel: "explorer",
+  isPinned: readPinned(),
+  drawerOpen: false,
+  sidebarWidth: readWidth(),
+  breakpoint: getBreakpoint(initialWidth),
+
+  togglePanel: (id) => {
+    const { activePanel, isPinned } = get();
+    if (activePanel === id) {
+      set({ activePanel: null, drawerOpen: false });
+    } else {
+      set({ activePanel: id, drawerOpen: !isPinned });
+    }
+  },
+
+  setActivePanel: (id) => set({ activePanel: id }),
+
+  setPinned: (pinned) => {
+    try {
+      localStorage.setItem(PINNED_KEY, String(pinned));
+    } catch { /* ignore */ }
+    set({ isPinned: pinned, drawerOpen: false });
+  },
+
+  setDrawerOpen: (open) => {
+    if (!open) {
+      const { isPinned } = get();
+      if (!isPinned) set({ drawerOpen: false, activePanel: null });
+      else set({ drawerOpen: false });
+    } else {
+      set({ drawerOpen: true });
+    }
+  },
+
+  setSidebarWidth: (width) => {
+    const clamped = Math.min(SIDEBAR_MAX_WIDTH, Math.max(SIDEBAR_MIN_WIDTH, width));
+    try {
+      localStorage.setItem(WIDTH_KEY, String(clamped));
+    } catch { /* ignore */ }
+    set({ sidebarWidth: clamped });
+  },
+
+  _setBreakpoint: (bp) => set({ breakpoint: bp }),
+}));

package/templates/agent/src/mainview/stores/use-theme-store.ts

@@ -0,0 +1,46 @@
+import { create } from "zustand";
+
+export type Theme = "light" | "dark";
+
+interface ThemeState {
+  theme: Theme;
+  setTheme: (theme: Theme) => void;
+  toggleTheme: () => void;
+}
+
+function getInitialTheme(): Theme {
+  if (typeof window === "undefined") return "dark";
+  const stored = localStorage.getItem("theme");
+  if (stored === "light" || stored === "dark") return stored;
+  return "dark";
+}
+
+function applyTheme(theme: Theme): void {
+  if (typeof document === "undefined") return;
+  if (theme === "dark") {
+    document.documentElement.classList.add("dark");
+  } else {
+    document.documentElement.classList.remove("dark");
+  }
+  localStorage.setItem("theme", theme);
+}
+
+export const useThemeStore = create<ThemeState>((set) => {
+  const initial = getInitialTheme();
+  applyTheme(initial);
+
+  return {
+    theme: initial,
+    setTheme: (theme) => {
+      applyTheme(theme);
+      set({ theme });
+    },
+    toggleTheme: () => {
+      set((state) => {
+        const next = state.theme === "dark" ? "light" : "dark";
+        applyTheme(next);
+        return { theme: next };
+      });
+    },
+  };
+});

package/templates/agent/src/mainview/stores/use-todo-store.ts

@@ -0,0 +1,54 @@
+import { create } from "zustand";
+import { apiClient } from "../lib/api-client";
+import { useLogStore } from "./use-log-store";
+import type { TodoItem, TodoStatus } from "../../shared/modules/todo";
+
+interface TodoState {
+  items: TodoItem[];
+  fetchItems: () => Promise<void>;
+  addItem: (content: string) => Promise<void>;
+  updateItem: (id: string, status: TodoStatus) => Promise<void>;
+  removeItem: (id: string) => Promise<void>;
+}
+
+export const useTodoStore = create<TodoState>((set) => ({
+  items: [],
+
+  fetchItems: async () => {
+    try {
+      const result = await apiClient.call("todo.list", {});
+      set({ items: result.items });
+    } catch (err) {
+      useLogStore.getState().addLog(`Todo fetch error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  addItem: async (content) => {
+    try {
+      const result = await apiClient.call("todo.add", { content });
+      set((s) => ({ items: [...s.items, result.item] }));
+    } catch (err) {
+      useLogStore.getState().addLog(`Todo add error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  updateItem: async (id, status) => {
+    try {
+      const result = await apiClient.call("todo.update", { id, status });
+      set((s) => ({
+        items: s.items.map((i) => (i.id === id ? result.item : i)),
+      }));
+    } catch (err) {
+      useLogStore.getState().addLog(`Todo update error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+
+  removeItem: async (id) => {
+    try {
+      await apiClient.call("todo.remove", { id });
+      set((s) => ({ items: s.items.filter((i) => i.id !== id) }));
+    } catch (err) {
+      useLogStore.getState().addLog(`Todo remove error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  },
+}));