pi-thread-engine 0.4.6 → 0.4.9

package/src/hello-world.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { helloWorld, DEFAULT_GREETING } from "./hello-world.js";
+
+describe("helloWorld", () => {
+  it("returns 'Hello, World!' when called with no arguments", () => {
+    expect(helloWorld()).toBe("Hello, World!");
+  });
+
+  it("returns 'Hello, World!' when called with undefined", () => {
+    expect(helloWorld(undefined)).toBe("Hello, World!");
+  });
+
+  it("returns 'Hello, Alice!' when called with 'Alice'", () => {
+    expect(helloWorld("Alice")).toBe("Hello, Alice!");
+  });
+
+  it("trims whitespace from the name", () => {
+    expect(helloWorld("  Charlie  ")).toBe("Hello, Charlie!");
+  });
+
+  it("returns 'Hello, World!' for empty string", () => {
+    expect(helloWorld("")).toBe("Hello, World!");
+  });
+});
+
+describe("DEFAULT_GREETING", () => {
+  it("is defined and equals 'Hello, World!'", () => {
+    expect(DEFAULT_GREETING).toBe("Hello, World!");
+  });
+});

package/src/hello-world.ts

@@ -0,0 +1,25 @@
+/**
+ * Default greeting string.
+ */
+export const DEFAULT_GREETING = "Hello, World!";
+
+/**
+ * Returns a greeting string.
+ *
+ * @param name - Optional name to include in the greeting.
+ *               `undefined`, empty string, or whitespace-only values
+ *               produce the default greeting.
+ * @returns The greeting string.
+ */
+export function helloWorld(name?: string): string {
+  if (name === undefined || name === null) {
+    return DEFAULT_GREETING;
+  }
+
+  const trimmed = name.trim();
+  if (trimmed === "") {
+    return DEFAULT_GREETING;
+  }
+
+  return `Hello, ${trimmed}!`;
+}

package/src/worktree-lifecycle.test.ts

@@ -0,0 +1,124 @@
+import { mkdtempSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ThreadExecutor } from "./core/executor.js";
+
+const worktreeMock = vi.hoisted(() => ({
+  createWorktree: vi.fn(),
+  findRepoRoot: vi.fn(() => "/repo"),
+  removeWorktree: vi.fn(() => true),
+  listWorktrees: vi.fn(() => []),
+  cleanupAll: vi.fn(() => ({ removed: 0, failed: 0 })),
+  pushWorktreeChanges: vi.fn(() => true),
+  isGitRepo: vi.fn(() => true),
+}));
+
+vi.mock("./core/worktree.js", () => worktreeMock);
+vi.mock("../extensions/index.js", async () => {
+  const actual = await vi.importActual("../extensions/index.js");
+  return actual;
+});
+
+const tempDirs: string[] = [];
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+  vi.clearAllMocks();
+});
+
+describe("worktree lifecycle", () => {
+  it("keeps worktree after exec so user can explicitly push/discard", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "pi-threads-"));
+    mkdirSync(join(dir, ".git"), { recursive: true });
+    tempDirs.push(dir);
+
+    worktreeMock.createWorktree.mockReturnValue({
+      path: dir,
+      branch: "pi-thread/t-1-abc",
+      threadId: "t-1",
+      createdAt: 0,
+      ahead: 0,
+      behind: 0,
+      dirty: false,
+    });
+
+    const pi = {
+      exec: vi.fn().mockResolvedValue({ code: 0, stdout: "ok", stderr: "" }),
+      sendUserMessage: vi.fn(),
+    } as any;
+    const registry = {
+      startThread: vi.fn(),
+      failTask: vi.fn(),
+      completeTask: vi.fn(),
+      startTask: vi.fn(),
+      get: vi.fn(),
+      kill: vi.fn(),
+    } as any;
+
+    const executor = new ThreadExecutor(pi, registry);
+    const thread = {
+      id: "t-1",
+      createdAt: 0,
+      config: { cwd: dir, backend: "native" },
+      tasks: [{ id: "t-1.1", prompt: "hi", state: "pending" }],
+    } as any;
+
+    await (executor as any).execWorktree(thread);
+
+    expect(worktreeMock.createWorktree).toHaveBeenCalledWith(dir, "t-1");
+    expect(worktreeMock.removeWorktree).not.toHaveBeenCalled();
+    expect(registry.completeTask).toHaveBeenCalledWith("t-1", "t-1.1", "ok");
+  });
+
+
+
+  it("does not create worktree tasks for lifecycle subcommands missing an id", async () => {
+    const { default: registerExtension } = await import("../extensions/index.js");
+    const handlers: Record<string, any> = {};
+    const notifications: string[] = [];
+    const pi = {
+      on: vi.fn(),
+      registerCommand: vi.fn((name: string, config: any) => { handlers[name] = config.handler; }),
+      registerTool: vi.fn(),
+      registerShortcut: vi.fn(),
+      sendUserMessage: vi.fn(),
+    } as any;
+    registerExtension(pi);
+
+    const ctx = {
+      cwd: "/repo",
+      ui: { notify: vi.fn((message: string) => notifications.push(message)), custom: vi.fn(), confirm: vi.fn() },
+      sessionManager: { getEntries: () => [] },
+    } as any;
+
+    await handlers.wthread("push", ctx);
+    await handlers.wthread("discard", ctx);
+
+    expect(notifications).toContain("Usage: /wthread push <id> [message]");
+    expect(notifications).toContain("Usage: /wthread discard <id>");
+    expect(worktreeMock.createWorktree).not.toHaveBeenCalled();
+    expect(worktreeMock.pushWorktreeChanges).not.toHaveBeenCalled();
+    expect(worktreeMock.removeWorktree).not.toHaveBeenCalled();
+  });
+
+  it("removes worktrees only on explicit discard", async () => {
+    const { default: registerExtension } = await import("../extensions/index.js");
+    const handlers: Record<string, any> = {};
+    const pi = {
+      on: vi.fn(),
+      registerCommand: vi.fn((name: string, config: any) => { handlers[name] = config.handler; }),
+      registerTool: vi.fn(),
+      registerShortcut: vi.fn(),
+      sendUserMessage: vi.fn(),
+    } as any;
+    registerExtension(pi);
+
+    await handlers.wthread("discard t-1", {
+      cwd: "/repo",
+      ui: { notify: vi.fn(), custom: vi.fn(), confirm: vi.fn() },
+      sessionManager: { getEntries: () => [] },
+    });
+
+    expect(worktreeMock.removeWorktree).toHaveBeenCalledWith("/repo", "t-1");
+  });
+});