@hienlh/ppm 0.1.0

package/tests/unit/providers/claude-agent-sdk.test.ts

@@ -0,0 +1,339 @@
+import { describe, it, expect, beforeEach, mock, spyOn } from "bun:test";
+import type { ChatEvent } from "../../../src/types/chat.ts";
+
+/**
+ * Helper: create an async iterable from an array of items with optional delay.
+ * Supports being "closed" mid-iteration (simulates SDK query.close()).
+ */
+function createMockQueryIterator(
+  items: Array<{ type: string; message?: unknown }>,
+  delayMs = 10,
+) {
+  let closed = false;
+  let closeResolve: (() => void) | undefined;
+  const closePromise = new Promise<void>((r) => (closeResolve = r));
+
+  const iterator: AsyncIterableIterator<any> & { close: () => void } = {
+    close() {
+      closed = true;
+      closeResolve?.();
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async next() {
+      if (closed) return { done: true, value: undefined };
+
+      if (items.length === 0) return { done: true, value: undefined };
+
+      // Small delay to simulate streaming
+      await new Promise((r) => setTimeout(r, delayMs));
+
+      if (closed) return { done: true, value: undefined };
+
+      const item = items.shift()!;
+      return { done: false, value: item };
+    },
+  };
+
+  return iterator;
+}
+
+// Mock the SDK module
+let mockQueryFn: ReturnType<typeof mock>;
+
+mock.module("@anthropic-ai/claude-agent-sdk", () => {
+  mockQueryFn = mock((...args: any[]) => {
+    // Default: return empty iterator. Tests override via mockQueryFn.mockImplementation()
+    return createMockQueryIterator([]);
+  });
+  return {
+    query: (...args: any[]) => mockQueryFn(...args),
+    listSessions: mock(() => Promise.resolve([])),
+    getSessionMessages: mock(() => Promise.resolve([])),
+  };
+});
+
+// Import AFTER mocking
+const { ClaudeAgentSdkProvider } = await import(
+  "../../../src/providers/claude-agent-sdk.ts"
+);
+
+describe("ClaudeAgentSdkProvider", () => {
+  let provider: InstanceType<typeof ClaudeAgentSdkProvider>;
+
+  beforeEach(() => {
+    provider = new ClaudeAgentSdkProvider();
+    mockQueryFn.mockReset();
+  });
+
+  describe("sendMessage", () => {
+    it("yields text events from partial messages", async () => {
+      const iter = createMockQueryIterator([
+        {
+          type: "partial",
+          message: { content: [{ type: "text", text: "Hello" }] },
+        },
+        {
+          type: "partial",
+          message: { content: [{ type: "text", text: "Hello world" }] },
+        },
+        {
+          type: "assistant",
+          message: { content: [{ type: "text", text: "Hello world" }] },
+        },
+        { type: "result" },
+      ]);
+      mockQueryFn.mockReturnValue(iter);
+
+      const session = await provider.createSession({});
+      const events: ChatEvent[] = [];
+      for await (const event of provider.sendMessage(session.id, "hi")) {
+        events.push(event);
+      }
+
+      const textEvents = events.filter((e) => e.type === "text");
+      expect(textEvents.length).toBeGreaterThan(0);
+
+      const fullText = textEvents.map((e) => (e as any).content).join("");
+      expect(fullText).toContain("Hello");
+
+      const done = events.find((e) => e.type === "done");
+      expect(done).toBeTruthy();
+    });
+
+    it("yields tool_use events from assistant messages", async () => {
+      const iter = createMockQueryIterator([
+        {
+          type: "assistant",
+          message: {
+            content: [
+              { type: "tool_use", name: "Read", input: { path: "test.ts" } },
+            ],
+          },
+        },
+        { type: "result" },
+      ]);
+      mockQueryFn.mockReturnValue(iter);
+
+      const session = await provider.createSession({});
+      const events: ChatEvent[] = [];
+      for await (const event of provider.sendMessage(session.id, "read file")) {
+        events.push(event);
+      }
+
+      const toolUse = events.find((e) => e.type === "tool_use");
+      expect(toolUse).toBeTruthy();
+      expect((toolUse as any).tool).toBe("Read");
+    });
+
+    it("always yields done event even on empty response", async () => {
+      const iter = createMockQueryIterator([{ type: "result" }]);
+      mockQueryFn.mockReturnValue(iter);
+
+      const session = await provider.createSession({});
+      const events: ChatEvent[] = [];
+      for await (const event of provider.sendMessage(session.id, "hi")) {
+        events.push(event);
+      }
+
+      expect(events).toHaveLength(1);
+      expect(events[0]!.type).toBe("done");
+    });
+
+    it("yields done event after SDK error (non-abort)", async () => {
+      mockQueryFn.mockImplementation(() => {
+        const iter = createMockQueryIterator([], 0);
+        // Override next to throw
+        iter.next = async () => {
+          throw new Error("SDK connection failed");
+        };
+        return iter;
+      });
+
+      const session = await provider.createSession({});
+      const events: ChatEvent[] = [];
+      for await (const event of provider.sendMessage(session.id, "hi")) {
+        events.push(event);
+      }
+
+      const error = events.find((e) => e.type === "error");
+      expect(error).toBeTruthy();
+      expect((error as any).message).toContain("SDK connection failed");
+
+      const done = events.find((e) => e.type === "done");
+      expect(done).toBeTruthy();
+    });
+
+    it("uses sessionId for first message and resume for subsequent", async () => {
+      // First call
+      mockQueryFn.mockReturnValue(
+        createMockQueryIterator([{ type: "result" }]),
+      );
+
+      const session = await provider.createSession({});
+      const events1: ChatEvent[] = [];
+      for await (const event of provider.sendMessage(session.id, "first")) {
+        events1.push(event);
+      }
+
+      expect(mockQueryFn).toHaveBeenCalledTimes(1);
+      const firstCall = mockQueryFn.mock.calls[0]![0];
+      expect(firstCall.options.sessionId).toBe(session.id);
+      expect(firstCall.options.resume).toBeUndefined();
+
+      // Second call
+      mockQueryFn.mockReturnValue(
+        createMockQueryIterator([{ type: "result" }]),
+      );
+
+      const events2: ChatEvent[] = [];
+      for await (const event of provider.sendMessage(session.id, "second")) {
+        events2.push(event);
+      }
+
+      const secondCall = mockQueryFn.mock.calls[1]![0];
+      expect(secondCall.options.sessionId).toBeUndefined();
+      expect(secondCall.options.resume).toBe(session.id);
+    });
+  });
+
+  describe("abortQuery (cancel)", () => {
+    it("calls close() on active SDK query", async () => {
+      const iter = createMockQueryIterator(
+        [
+          {
+            type: "partial",
+            message: { content: [{ type: "text", text: "Working..." }] },
+          },
+          // Many more items that won't be reached after close
+          {
+            type: "partial",
+            message: {
+              content: [{ type: "text", text: "Working... still going" }],
+            },
+          },
+          {
+            type: "partial",
+            message: {
+              content: [
+                { type: "text", text: "Working... still going... more" },
+              ],
+            },
+          },
+          { type: "result" },
+        ],
+        100, // slow enough to cancel mid-stream
+      );
+
+      const closeSpy = spyOn(iter, "close");
+      mockQueryFn.mockReturnValue(iter);
+
+      const session = await provider.createSession({});
+
+      // Start streaming in background
+      const events: ChatEvent[] = [];
+      const streamPromise = (async () => {
+        for await (const event of provider.sendMessage(session.id, "hello")) {
+          events.push(event);
+        }
+      })();
+
+      // Wait for first event
+      await new Promise((r) => setTimeout(r, 50));
+
+      // Cancel
+      provider.abortQuery(session.id);
+
+      expect(closeSpy).toHaveBeenCalledTimes(1);
+
+      // Wait for stream to finish
+      await streamPromise;
+
+      // Should have done event (always emitted)
+      const done = events.find((e) => e.type === "done");
+      expect(done).toBeTruthy();
+    });
+
+    it("does not yield error event on abort", async () => {
+      // Simulate SDK throwing abort error when query is closed
+      let rejectNext: ((err: Error) => void) | undefined;
+
+      mockQueryFn.mockImplementation(() => {
+        let callCount = 0;
+        const q = {
+          close() {
+            rejectNext?.(new Error("aborted"));
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          },
+          async next(): Promise<{ done: boolean; value: any }> {
+            callCount++;
+            if (callCount === 1) {
+              return {
+                done: false,
+                value: {
+                  type: "partial",
+                  message: { content: [{ type: "text", text: "Hi" }] },
+                },
+              };
+            }
+            // Second call: wait to be aborted
+            return new Promise((resolve, reject) => {
+              rejectNext = reject;
+              // Also resolve after timeout as fallback
+              setTimeout(
+                () => resolve({ done: true, value: undefined }),
+                5000,
+              );
+            });
+          },
+        };
+        return q;
+      });
+
+      const session = await provider.createSession({});
+      const events: ChatEvent[] = [];
+      const streamPromise = (async () => {
+        for await (const event of provider.sendMessage(session.id, "test")) {
+          events.push(event);
+        }
+      })();
+
+      // Wait for first event
+      await new Promise((r) => setTimeout(r, 50));
+
+      // Cancel — should trigger abort error
+      provider.abortQuery(session.id);
+
+      await streamPromise;
+
+      // Should NOT have an error event (abort is intentional)
+      const errors = events.filter((e) => e.type === "error");
+      expect(errors).toHaveLength(0);
+
+      // Should still have done event
+      const done = events.find((e) => e.type === "done");
+      expect(done).toBeTruthy();
+    });
+
+    it("abortQuery is no-op when no active query", () => {
+      // Should not throw
+      expect(() => provider.abortQuery("nonexistent-session")).not.toThrow();
+    });
+
+    it("cleans up activeQueries after stream ends", async () => {
+      const iter = createMockQueryIterator([{ type: "result" }]);
+      mockQueryFn.mockReturnValue(iter);
+
+      const session = await provider.createSession({});
+      for await (const _ of provider.sendMessage(session.id, "hi")) {
+        // consume
+      }
+
+      // abortQuery should be no-op now (query already cleaned up)
+      expect(() => provider.abortQuery(session.id)).not.toThrow();
+    });
+  });
+});

package/tests/unit/providers/mock-provider.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect } from "bun:test";
+import { MockProvider } from "../../../src/providers/mock-provider.ts";
+
+describe("MockProvider", () => {
+  it("creates a session with UUID and metadata", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({
+      projectName: "test-project",
+      title: "Test Chat",
+    });
+
+    expect(session.id).toBeTruthy();
+    expect(session.providerId).toBe("mock");
+    expect(session.title).toBe("Test Chat");
+    expect(session.projectName).toBe("test-project");
+    expect(session.createdAt).toBeTruthy();
+  });
+
+  it("resumes an existing session", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({ title: "Original" });
+    const resumed = await provider.resumeSession(session.id);
+
+    expect(resumed.id).toBe(session.id);
+    expect(resumed.title).toBe("Original");
+  });
+
+  it("throws on resume of non-existent session", async () => {
+    const provider = new MockProvider();
+    expect(provider.resumeSession("non-existent")).rejects.toThrow();
+  });
+
+  it("lists sessions", async () => {
+    const provider = new MockProvider();
+    await provider.createSession({ title: "Chat 1" });
+    await provider.createSession({ title: "Chat 2" });
+    const sessions = await provider.listSessions();
+
+    expect(sessions).toHaveLength(2);
+    expect(sessions.map((s) => s.title)).toContain("Chat 1");
+    expect(sessions.map((s) => s.title)).toContain("Chat 2");
+  });
+
+  it("deletes a session", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({ title: "Doomed" });
+    await provider.deleteSession(session.id);
+    const sessions = await provider.listSessions();
+
+    expect(sessions).toHaveLength(0);
+  });
+
+  it("streams text events for a simple message", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({});
+    const events: any[] = [];
+
+    for await (const event of provider.sendMessage(session.id, "hello")) {
+      events.push(event);
+    }
+
+    const textEvents = events.filter((e) => e.type === "text");
+    const doneEvents = events.filter((e) => e.type === "done");
+
+    expect(textEvents.length).toBeGreaterThan(0);
+    expect(doneEvents).toHaveLength(1);
+    expect(doneEvents[0].sessionId).toBe(session.id);
+  });
+
+  it("yields tool_use events for messages containing 'file'", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({});
+    const events: any[] = [];
+
+    for await (const event of provider.sendMessage(session.id, "read the file")) {
+      events.push(event);
+    }
+
+    const toolUse = events.find((e) => e.type === "tool_use");
+    const toolResult = events.find((e) => e.type === "tool_result");
+
+    expect(toolUse).toBeTruthy();
+    expect(toolUse.tool).toBe("Read");
+    expect(toolResult).toBeTruthy();
+    expect(toolResult.output).toContain("Main entry point");
+  });
+
+  it("yields approval_request for messages containing 'delete'", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({});
+    const events: any[] = [];
+
+    for await (const event of provider.sendMessage(session.id, "delete the temp files")) {
+      events.push(event);
+    }
+
+    const approval = events.find((e) => e.type === "approval_request");
+    expect(approval).toBeTruthy();
+    expect(approval.tool).toBe("Bash");
+    expect(approval.requestId).toBeTruthy();
+  });
+
+  it("updates session title from first message", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({});
+
+    for await (const _ of provider.sendMessage(session.id, "My first question about testing")) {
+      // consume
+    }
+
+    const sessions = await provider.listSessions();
+    const updated = sessions.find((s) => s.id === session.id);
+    expect(updated?.title).toContain("My first question");
+  });
+
+  it("stores message history", async () => {
+    const provider = new MockProvider();
+    const session = await provider.createSession({});
+
+    for await (const _ of provider.sendMessage(session.id, "hello")) {
+      // consume
+    }
+
+    const messages = provider.getMessages(session.id);
+    expect(messages).toHaveLength(2); // user + assistant
+    expect(messages[0].role).toBe("user");
+    expect(messages[0].content).toBe("hello");
+    expect(messages[1].role).toBe("assistant");
+    expect(messages[1].content).toBeTruthy();
+  });
+
+  it("yields error for non-existent session", async () => {
+    const provider = new MockProvider();
+    const events: any[] = [];
+
+    for await (const event of provider.sendMessage("bad-id", "hello")) {
+      events.push(event);
+    }
+
+    expect(events[0].type).toBe("error");
+    expect(events[0].message).toBe("Session not found");
+  });
+});

package/tests/unit/services/chat-service.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from "bun:test";
+import { chatService } from "../../../src/services/chat.service.ts";
+
+describe("ChatService", () => {
+  it("creates session with default provider", async () => {
+    const session = await chatService.createSession(undefined, {
+      title: "Test",
+    });
+
+    expect(session.id).toBeTruthy();
+    expect(session.providerId).toBe("claude-sdk"); // default provider
+    expect(session.title).toBe("Test");
+  });
+
+  it("creates session with specific provider", async () => {
+    const session = await chatService.createSession("mock", {
+      title: "Mock Chat",
+    });
+
+    expect(session.providerId).toBe("mock");
+    expect(session.title).toBe("Mock Chat");
+  });
+
+  it("throws on unknown provider", async () => {
+    expect(
+      chatService.createSession("nonexistent", {}),
+    ).rejects.toThrow('Provider "nonexistent" not found');
+  });
+
+  it("lists sessions from all providers", async () => {
+    // Create sessions in mock provider
+    await chatService.createSession("mock", { title: "A" });
+    await chatService.createSession("mock", { title: "B" });
+
+    const all = await chatService.listSessions();
+    // Should include at least the mock sessions
+    const mockSessions = all.filter((s) => s.providerId === "mock");
+    expect(mockSessions.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("lists sessions filtered by provider", async () => {
+    await chatService.createSession("mock", { title: "Filtered" });
+    const sessions = await chatService.listSessions("mock");
+
+    expect(sessions.length).toBeGreaterThanOrEqual(1);
+    expect(sessions.every((s) => s.providerId === "mock")).toBe(true);
+  });
+
+  it("deletes session", async () => {
+    const session = await chatService.createSession("mock", { title: "Delete me" });
+    await chatService.deleteSession("mock", session.id);
+
+    const sessions = await chatService.listSessions("mock");
+    expect(sessions.find((s) => s.id === session.id)).toBeUndefined();
+  });
+
+  it("streams events from sendMessage", async () => {
+    const session = await chatService.createSession("mock", {});
+    const events: any[] = [];
+
+    for await (const event of chatService.sendMessage("mock", session.id, "hello world")) {
+      events.push(event);
+    }
+
+    expect(events.some((e) => e.type === "text")).toBe(true);
+    expect(events.some((e) => e.type === "done")).toBe(true);
+  });
+
+  it("returns error for unknown provider in sendMessage", async () => {
+    const events: any[] = [];
+
+    for await (const event of chatService.sendMessage("bad-provider", "id", "hello")) {
+      events.push(event);
+    }
+
+    expect(events[0].type).toBe("error");
+    expect(events[0].message).toContain("not found");
+  });
+
+  it("getSession finds session across providers", async () => {
+    const session = await chatService.createSession("mock", { title: "Findable" });
+    const found = chatService.getSession(session.id);
+
+    expect(found).not.toBeNull();
+    expect(found?.id).toBe(session.id);
+  });
+
+  it("getMessages returns history for mock provider", async () => {
+    const session = await chatService.createSession("mock", {});
+
+    for await (const _ of chatService.sendMessage("mock", session.id, "test msg")) {
+      // consume
+    }
+
+    const messages = await chatService.getMessages("mock", session.id);
+    expect(messages.length).toBeGreaterThanOrEqual(2); // user + assistant
+    expect(messages[0].role).toBe("user");
+    expect(messages[0].content).toBe("test msg");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/web/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["node_modules", "dist"]
+}

package/vite.config.ts

@@ -0,0 +1,62 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import { VitePWA } from "vite-plugin-pwa";
+import { resolve } from "path";
+
+export default defineConfig({
+  plugins: [
+    react(),
+    tailwindcss(),
+    VitePWA({
+      registerType: "autoUpdate",
+      manifest: {
+        name: "PPM — Personal Project Manager",
+        short_name: "PPM",
+        description: "Mobile-first web IDE for managing code projects",
+        theme_color: "#0f1419",
+        background_color: "#0f1419",
+        display: "standalone",
+        orientation: "any",
+        icons: [
+          { src: "/icon-192.png", sizes: "192x192", type: "image/png" },
+          { src: "/icon-512.png", sizes: "512x512", type: "image/png" },
+        ],
+      },
+      workbox: {
+        globPatterns: ["**/*.{js,css,html,ico,png,svg,woff2}"],
+        runtimeCaching: [
+          {
+            urlPattern: /^https?:\/\/.*\/api\//,
+            handler: "NetworkOnly",
+          },
+          {
+            urlPattern: /^https?:\/\/.*\/ws\//,
+            handler: "NetworkOnly",
+          },
+        ],
+      },
+    }),
+  ],
+  root: "src/web",
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "src/web"),
+    },
+  },
+  build: {
+    outDir: resolve(__dirname, "dist/web"),
+    emptyOutDir: true,
+  },
+  server: {
+    host: true,
+    port: 5173,
+    proxy: {
+      "/api": "http://localhost:8080",
+      "/ws": {
+        target: "ws://localhost:8080",
+        ws: true,
+      },
+    },
+  },
+});