@dyyz1993/create-agent 2.1.0 → 2.1.2

package/templates/general/src/mainview/stores/__tests__/use-feed-store.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/api-client", () => ({
+	apiClient: {
+		call: vi.fn(),
+		subscribe: vi.fn(() => "sub-id"),
+		unsubscribe: vi.fn(),
+	},
+}));
+
+describe("useFeedStore", () => {
+	beforeEach(async () => {
+		vi.resetModules();
+	});
+
+	it("should have correct initial state", async () => {
+		const { useFeedStore } = await import("../use-feed-store");
+		const state = useFeedStore.getState();
+		expect(state.posts).toEqual([]);
+		expect(state.author).toBe("alice");
+		expect(state.category).toBe("tech");
+		expect(state.content).toBe("");
+		expect(state.loading).toBe(false);
+	});
+
+	it("should set author", async () => {
+		const { useFeedStore } = await import("../use-feed-store");
+		useFeedStore.getState().setAuthor("bob");
+		expect(useFeedStore.getState().author).toBe("bob");
+	});
+
+	it("should set category", async () => {
+		const { useFeedStore } = await import("../use-feed-store");
+		useFeedStore.getState().setCategory("news");
+		expect(useFeedStore.getState().category).toBe("news");
+	});
+
+	it("should set content", async () => {
+		const { useFeedStore } = await import("../use-feed-store");
+		useFeedStore.getState().setContent("hello world");
+		expect(useFeedStore.getState().content).toBe("hello world");
+	});
+
+	it("should create post and clear content", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useFeedStore } = await import("../use-feed-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ id: "post-1" });
+		useFeedStore.getState().setContent("  new post  ");
+
+		await useFeedStore.getState().createPost();
+		expect(apiClient.call).toHaveBeenCalledWith("feed.post", {
+			content: "new post",
+			category: "tech",
+			author: "alice",
+		});
+		expect(useFeedStore.getState().content).toBe("");
+		expect(useFeedStore.getState().loading).toBe(false);
+	});
+
+	it("should not create post with empty content", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useFeedStore } = await import("../use-feed-store");
+		useFeedStore.setState({ content: "   " });
+		(apiClient.call as ReturnType<typeof vi.fn>).mockClear();
+
+		await useFeedStore.getState().createPost();
+		expect(apiClient.call).not.toHaveBeenCalled();
+	});
+
+	it("should set loading to false on createPost error", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useFeedStore } = await import("../use-feed-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error("fail"));
+		useFeedStore.getState().setContent("content");
+
+		await useFeedStore.getState().createPost();
+		expect(useFeedStore.getState().loading).toBe(false);
+		expect(useFeedStore.getState().content).toBe("content");
+	});
+
+	it("should load posts", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useFeedStore } = await import("../use-feed-store");
+		const posts = [
+			{ id: "1", content: "hello", category: "tech", author: "alice", timestamp: Date.now() },
+		];
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ posts });
+
+		await useFeedStore.getState().loadPosts();
+		expect(useFeedStore.getState().posts).toHaveLength(1);
+	});
+
+	it("should add a post locally", async () => {
+		const { useFeedStore } = await import("../use-feed-store");
+		const post = {
+			id: "p1",
+			content: "hi",
+			category: "tech" as const,
+			author: "alice",
+			timestamp: Date.now(),
+		};
+		useFeedStore.getState().addPost(post);
+		expect(useFeedStore.getState().posts).toHaveLength(1);
+		expect(useFeedStore.getState().posts[0].id).toBe("p1");
+	});
+});
+
+describe("useEventStreamStore", () => {
+	beforeEach(async () => {
+		vi.resetModules();
+	});
+
+	it("should have correct initial state", async () => {
+		const { useEventStreamStore } = await import("../use-feed-store");
+		const state = useEventStreamStore.getState();
+		expect(state.entries).toEqual([]);
+		expect(state.activeEventType).toBe("feed.update");
+		expect(state.activeFilter).toBe("");
+		expect(state.subscriptionId).toBeNull();
+		expect(state.subscribed).toBe(false);
+	});
+
+	it("should set active event type", async () => {
+		const { useEventStreamStore } = await import("../use-feed-store");
+		useEventStreamStore.getState().setActiveEventType("chat.message");
+		expect(useEventStreamStore.getState().activeEventType).toBe("chat.message");
+	});
+
+	it("should set active filter", async () => {
+		const { useEventStreamStore } = await import("../use-feed-store");
+		useEventStreamStore.getState().setActiveFilter('{"key":"val"}');
+		expect(useEventStreamStore.getState().activeFilter).toBe('{"key":"val"}');
+	});
+
+	it("should subscribe and set state", async () => {
+		const { useEventStreamStore } = await import("../use-feed-store");
+		await useEventStreamStore.getState().handleSubscribe();
+		expect(useEventStreamStore.getState().subscribed).toBe(true);
+		expect(useEventStreamStore.getState().subscriptionId).toBe("sub-id");
+	});
+
+	it("should unsubscribe and clear state", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useEventStreamStore } = await import("../use-feed-store");
+		await useEventStreamStore.getState().handleSubscribe();
+
+		useEventStreamStore.getState().handleUnsubscribe();
+		expect(apiClient.unsubscribe).toHaveBeenCalledWith("sub-id");
+		expect(useEventStreamStore.getState().subscribed).toBe(false);
+		expect(useEventStreamStore.getState().subscriptionId).toBeNull();
+	});
+
+	it("should add entries keeping max 50", async () => {
+		const { useEventStreamStore } = await import("../use-feed-store");
+		for (let i = 0; i < 55; i++) {
+			useEventStreamStore.getState().addEntry("feed.update", { i }, {});
+		}
+		expect(useEventStreamStore.getState().entries.length).toBeLessThanOrEqual(50);
+	});
+});

package/templates/general/src/mainview/stores/__tests__/use-git-store.test.ts

@@ -0,0 +1,313 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("../../lib/api-client", () => ({
+	apiClient: { call: vi.fn() },
+}));
+
+vi.mock("../use-log-store", () => ({
+	useLogStore: { getState: () => ({ addLog: vi.fn() }) },
+}));
+
+describe("useGitStore", () => {
+	beforeEach(async () => {
+		vi.resetModules();
+	});
+
+	it("should have correct initial state", async () => {
+		const { useGitStore } = await import("../use-git-store");
+		const state = useGitStore.getState();
+		expect(state.branch).toBe("");
+		expect(state.ahead).toBe(0);
+		expect(state.behind).toBe(0);
+		expect(state.staged).toEqual([]);
+		expect(state.changed).toEqual([]);
+		expect(state.untracked).toEqual([]);
+		expect(state.commits).toEqual([]);
+		expect(state.loadingCommits).toBe(false);
+		expect(state.currentDiff).toBeNull();
+		expect(state.loadingDiff).toBe(false);
+		expect(state.expandedCommits).toEqual(new Set());
+		expect(state.commitFiles).toEqual({});
+		expect(state.loadingCommitFiles).toEqual(new Set());
+		expect(state.branches).toEqual([]);
+		expect(state.loadingBranches).toBe(false);
+		expect(state.worktrees).toEqual([]);
+		expect(state.loadingAction).toBeNull();
+	});
+
+	it("should fetch status", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+			branch: "main",
+			ahead: 2,
+			behind: 1,
+			staged: [{ path: "a.ts", status: "modified" }],
+			changed: [{ path: "b.ts", status: "added" }],
+			untracked: ["c.ts"],
+		});
+
+		await useGitStore.getState().fetchStatus("/repo");
+		const state = useGitStore.getState();
+		expect(state.branch).toBe("main");
+		expect(state.ahead).toBe(2);
+		expect(state.behind).toBe(1);
+		expect(state.staged).toHaveLength(1);
+		expect(state.untracked).toEqual(["c.ts"]);
+	});
+
+	it("should fetch diff", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+			filePath: "a.ts",
+			diff: "+hello",
+			oldContent: "",
+			newContent: "hello",
+		});
+
+		await useGitStore.getState().fetchDiff("/repo", "a.ts");
+		const state = useGitStore.getState();
+		expect(state.currentDiff).not.toBeNull();
+		expect(state.currentDiff!.filePath).toBe("a.ts");
+		expect(state.loadingDiff).toBe(false);
+	});
+
+	it("should set loadingDiff on fetchDiff error", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error("fail"));
+
+		await useGitStore.getState().fetchDiff("/repo", "a.ts");
+		expect(useGitStore.getState().loadingDiff).toBe(false);
+	});
+
+	it("should clear diff", async () => {
+		const { useGitStore } = await import("../use-git-store");
+		useGitStore.setState({
+			currentDiff: { filePath: "a.ts", diff: "", oldContent: "", newContent: "" },
+		});
+		useGitStore.getState().clearDiff();
+		expect(useGitStore.getState().currentDiff).toBeNull();
+	});
+
+	it("should fetch log", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		const commits = [
+			{ hash: "abc123", shortHash: "abc1234", message: "init", author: "user", date: "2024-01-01" },
+		];
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ commits });
+
+		await useGitStore.getState().fetchLog("/repo");
+		expect(useGitStore.getState().commits).toHaveLength(1);
+		expect(useGitStore.getState().loadingCommits).toBe(false);
+	});
+
+	it("should set loadingCommits false on fetchLog error", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error("fail"));
+
+		await useGitStore.getState().fetchLog("/repo");
+		expect(useGitStore.getState().loadingCommits).toBe(false);
+	});
+
+	it("should toggle commit expand and load files", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+			files: [{ path: "a.ts", status: "modified" }],
+		});
+
+		await useGitStore.getState().toggleCommitExpand("/repo", "abc123");
+		const state = useGitStore.getState();
+		expect(state.expandedCommits.has("abc123")).toBe(true);
+		expect(state.commitFiles["abc123"]).toHaveLength(1);
+	});
+
+	it("should collapse expanded commit on toggle", async () => {
+		const { useGitStore } = await import("../use-git-store");
+		useGitStore.setState({ expandedCommits: new Set(["abc123"]) });
+
+		await useGitStore.getState().toggleCommitExpand("/repo", "abc123");
+		expect(useGitStore.getState().expandedCommits.has("abc123")).toBe(false);
+	});
+
+	it("should fetch branches", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+			branches: [
+				{ name: "main", isCurrent: true, isRemote: false },
+				{ name: "dev", isCurrent: false, isRemote: false },
+			],
+		});
+
+		await useGitStore.getState().fetchBranches("/repo");
+		expect(useGitStore.getState().branches).toHaveLength(2);
+		expect(useGitStore.getState().loadingBranches).toBe(false);
+	});
+
+	it("should checkout and refresh", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+		callMock.mockResolvedValueOnce(undefined);
+		callMock.mockResolvedValueOnce({
+			branch: "dev",
+			ahead: 0,
+			behind: 0,
+			staged: [],
+			changed: [],
+			untracked: [],
+		});
+
+		await useGitStore.getState().checkout("/repo", "dev");
+		expect(callMock).toHaveBeenCalledWith("git.checkout", { repoPath: "/repo", branch: "dev" });
+		expect(useGitStore.getState().loadingAction).toBeNull();
+	});
+
+	it("should stage files and refresh", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+		callMock.mockResolvedValueOnce(undefined);
+		callMock.mockResolvedValueOnce({
+			branch: "main",
+			ahead: 0,
+			behind: 0,
+			staged: [],
+			changed: [],
+			untracked: [],
+		});
+
+		await useGitStore.getState().stageFiles("/repo", ["a.ts"]);
+		expect(callMock).toHaveBeenCalledWith("git.add", { repoPath: "/repo", paths: ["a.ts"] });
+		expect(useGitStore.getState().loadingAction).toBeNull();
+	});
+
+	it("should unstage files and refresh", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+		callMock.mockResolvedValueOnce(undefined);
+		callMock.mockResolvedValueOnce({
+			branch: "main",
+			ahead: 0,
+			behind: 0,
+			staged: [],
+			changed: [],
+			untracked: [],
+		});
+
+		await useGitStore.getState().unstageFiles("/repo", ["a.ts"]);
+		expect(callMock).toHaveBeenCalledWith("git.reset", { repoPath: "/repo", paths: ["a.ts"] });
+		expect(useGitStore.getState().loadingAction).toBeNull();
+	});
+
+	it("should commit and refresh", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+		callMock.mockResolvedValueOnce({ shortHash: "abc1234" });
+		callMock.mockResolvedValueOnce({
+			branch: "main",
+			ahead: 0,
+			behind: 0,
+			staged: [],
+			changed: [],
+			untracked: [],
+		});
+
+		await useGitStore.getState().commit("/repo", "init commit");
+		expect(callMock).toHaveBeenCalledWith("git.commit", {
+			repoPath: "/repo",
+			message: "init commit",
+		});
+		expect(useGitStore.getState().loadingAction).toBeNull();
+	});
+
+	it("should push and refresh", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+		callMock.mockResolvedValueOnce(undefined);
+		callMock.mockResolvedValueOnce({
+			branch: "main",
+			ahead: 0,
+			behind: 0,
+			staged: [],
+			changed: [],
+			untracked: [],
+		});
+
+		await useGitStore.getState().push("/repo");
+		expect(callMock).toHaveBeenCalledWith("git.push", { repoPath: "/repo" });
+		expect(useGitStore.getState().loadingAction).toBeNull();
+	});
+
+	it("should pull and refresh", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		const callMock = apiClient.call as ReturnType<typeof vi.fn>;
+		callMock.mockResolvedValueOnce(undefined);
+		callMock.mockResolvedValueOnce({
+			branch: "main",
+			ahead: 0,
+			behind: 0,
+			staged: [],
+			changed: [],
+			untracked: [],
+		});
+
+		await useGitStore.getState().pull("/repo");
+		expect(callMock).toHaveBeenCalledWith("git.pull", { repoPath: "/repo" });
+		expect(useGitStore.getState().loadingAction).toBeNull();
+	});
+
+	it("should fetch worktrees", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+			worktrees: [
+				{ path: "/repo", branch: "main", isMain: true },
+				{ path: "/repo-wt", branch: "dev", isMain: false },
+			],
+		});
+
+		await useGitStore.getState().fetchWorktrees("/repo");
+		expect(useGitStore.getState().worktrees).toHaveLength(2);
+	});
+
+	it("should fetch commit file diff", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+			filePath: "a.ts",
+			diff: "+x",
+			oldContent: "",
+			newContent: "x",
+		});
+
+		await useGitStore.getState().fetchCommitFileDiff("/repo", "abc123", "a.ts");
+		expect(useGitStore.getState().currentDiff!.filePath).toBe("a.ts");
+		expect(useGitStore.getState().loadingDiff).toBe(false);
+	});
+
+	it("should refresh by calling fetchStatus", async () => {
+		const { apiClient } = await import("../../lib/api-client");
+		const { useGitStore } = await import("../use-git-store");
+		(apiClient.call as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+			branch: "main",
+			ahead: 0,
+			behind: 0,
+			staged: [],
+			changed: [],
+			untracked: [],
+		});
+
+		await useGitStore.getState().refresh("/repo");
+		expect(apiClient.call).toHaveBeenCalledWith("git.status", { repoPath: "/repo" });
+	});
+});

package/templates/general/src/mainview/stores/__tests__/use-notification-store.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+describe("useNotificationStore", () => {
+	beforeEach(async () => {
+		vi.resetModules();
+		vi.useFakeTimers();
+	});
+
+	afterEach(() => {
+		vi.useRealTimers();
+	});
+
+	it("should have correct initial state", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		const state = useNotificationStore.getState();
+		expect(state.notifications).toEqual([]);
+		expect(state.panelOpen).toBe(false);
+	});
+
+	it("should push a notification", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "hello", level: "info" });
+		const state = useNotificationStore.getState();
+		expect(state.notifications).toHaveLength(1);
+		expect(state.notifications[0].message).toBe("hello");
+		expect(state.notifications[0].level).toBe("info");
+		expect(state.notifications[0].read).toBe(false);
+		expect(state.notifications[0].id).toMatch(/^notif-/);
+	});
+
+	it("should push notification with sessionId", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "test", level: "warning", sessionId: "s1" });
+		expect(useNotificationStore.getState().notifications[0].sessionId).toBe("s1");
+	});
+
+	it("should auto-dismiss info notifications after 5s", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "temp", level: "info" });
+		expect(useNotificationStore.getState().notifications).toHaveLength(1);
+
+		vi.advanceTimersByTime(5000);
+		expect(useNotificationStore.getState().notifications).toHaveLength(0);
+	});
+
+	it("should not auto-dismiss warning notifications", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "warn", level: "warning" });
+
+		vi.advanceTimersByTime(10000);
+		expect(useNotificationStore.getState().notifications).toHaveLength(1);
+	});
+
+	it("should not auto-dismiss error notifications", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "err", level: "error" });
+
+		vi.advanceTimersByTime(10000);
+		expect(useNotificationStore.getState().notifications).toHaveLength(1);
+	});
+
+	it("should mark a notification as read", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "test", level: "warning" });
+		const id = useNotificationStore.getState().notifications[0].id;
+
+		useNotificationStore.getState().markRead(id);
+		expect(useNotificationStore.getState().notifications[0].read).toBe(true);
+	});
+
+	it("should mark all notifications as read", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "a", level: "warning" });
+		useNotificationStore.getState().push({ message: "b", level: "error" });
+
+		useNotificationStore.getState().markAllRead();
+		const state = useNotificationStore.getState();
+		expect(state.notifications.every((n) => n.read)).toBe(true);
+	});
+
+	it("should dismiss a notification", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "bye", level: "warning" });
+		const id = useNotificationStore.getState().notifications[0].id;
+
+		useNotificationStore.getState().dismiss(id);
+		expect(useNotificationStore.getState().notifications).toHaveLength(0);
+	});
+
+	it("should clear all notifications", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().push({ message: "a", level: "error" });
+		useNotificationStore.getState().push({ message: "b", level: "error" });
+
+		useNotificationStore.getState().clearAll();
+		expect(useNotificationStore.getState().notifications).toHaveLength(0);
+	});
+
+	it("should toggle panel", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		expect(useNotificationStore.getState().panelOpen).toBe(false);
+		useNotificationStore.getState().togglePanel();
+		expect(useNotificationStore.getState().panelOpen).toBe(true);
+		useNotificationStore.getState().togglePanel();
+		expect(useNotificationStore.getState().panelOpen).toBe(false);
+	});
+
+	it("should set panel open explicitly", async () => {
+		const { useNotificationStore } = await import("../use-notification-store");
+		useNotificationStore.getState().setPanelOpen(true);
+		expect(useNotificationStore.getState().panelOpen).toBe(true);
+		useNotificationStore.getState().setPanelOpen(false);
+		expect(useNotificationStore.getState().panelOpen).toBe(false);
+	});
+});