@selesai/code 0.13.13 → 0.13.15

package/dist/extensions/pi-hermes-memory/tests/handlers/insights.test.ts

@@ -0,0 +1,157 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { registerInsightsCommand } from "../../src/handlers/insights.js";
+
+/**
+ * Create a mock store with given memory and user entries,
+ * then register the insights command and return the handler
+ * plus the captured notify calls.
+ */
+async function setupCommand(
+  memoryEntries: string[],
+  userEntries: string[],
+): Promise<{
+  handler: Function;
+  notifyCalls: { message: string; severity: string }[];
+}> {
+  const notifyCalls: { message: string; severity: string }[] = [];
+
+  const mockStore = {
+    getMemoryEntries: () => [...memoryEntries],
+    getUserEntries: () => [...userEntries],
+  };
+
+  const commands: { name: string; handler: Function }[] = [];
+  const mockPi = {
+    registerCommand: (name: string, opts: any) => {
+      commands.push({ name, handler: opts.handler });
+    },
+  };
+
+  registerInsightsCommand(mockPi as any, mockStore as any, null, "test-project");
+
+  assert.ok(commands.length === 1, "Expected exactly one registered command");
+  return { handler: commands[0].handler, notifyCalls };
+}
+
+/** Invoke the handler with a fake context that captures notify calls. */
+async function invoke(
+  handler: Function,
+  notifyCalls: { message: string; severity: string }[],
+): Promise<string> {
+  await handler({}, {
+    ui: {
+      notify: (message: string, severity: string) => {
+        notifyCalls.push({ message, severity });
+      },
+    },
+  });
+  assert.ok(notifyCalls.length === 1, "Expected exactly one notify call");
+  return notifyCalls[0].message;
+}
+
+describe("registerInsightsCommand", () => {
+  it("command is registered", async () => {
+    const { handler } = await setupCommand([], []);
+    assert.ok(typeof handler === "function");
+  });
+
+  it("shows MEMORY section with numbered entries", async () => {
+    const { handler, notifyCalls } = await setupCommand(
+      ["first entry", "second entry"],
+      [],
+    );
+    const output = await invoke(handler, notifyCalls);
+
+    assert.match(output, /1\.\s/);
+    assert.match(output, /2\.\s/);
+    assert.ok(output.includes("first entry"));
+    assert.ok(output.includes("second entry"));
+  });
+
+  it("shows USER PROFILE section", async () => {
+    const { handler, notifyCalls } = await setupCommand([], ["user fact"]);
+    const output = await invoke(handler, notifyCalls);
+
+    assert.ok(output.includes("USER PROFILE"));
+    assert.ok(output.includes("user fact"));
+  });
+
+  it('shows "(empty)" when no entries exist', async () => {
+    const { handler, notifyCalls } = await setupCommand([], []);
+    const output = await invoke(handler, notifyCalls);
+
+    const emptyMatches = output.match(/\(empty\)/g);
+    assert.ok(
+      emptyMatches && emptyMatches.length === 2,
+      "Expected (empty) in both MEMORY and USER sections",
+    );
+  });
+
+  it("entries truncated to 100 chars", async () => {
+    const longEntry = "x".repeat(200);
+    const { handler, notifyCalls } = await setupCommand([longEntry], []);
+    const output = await invoke(handler, notifyCalls);
+
+    // Should contain first 100 chars + "..."
+    assert.ok(output.includes("x".repeat(100) + "..."));
+    // Should NOT contain the full 200-char entry
+    assert.ok(!output.includes("x".repeat(200)));
+  });
+
+  it("box drawing characters in output", async () => {
+    const { handler, notifyCalls } = await setupCommand([], []);
+    const output = await invoke(handler, notifyCalls);
+
+    assert.ok(output.includes("╔"));
+    assert.ok(output.includes("═"));
+    assert.ok(output.includes("║"));
+    assert.ok(output.includes("╗"));
+    assert.ok(output.includes("╚"));
+    assert.ok(output.includes("╝"));
+  });
+
+  it("notification called with info severity", async () => {
+    const { handler, notifyCalls } = await setupCommand([], []);
+    await invoke(handler, notifyCalls);
+
+    assert.strictEqual(notifyCalls[0].severity, "info");
+  });
+
+  it("multiple entries displayed correctly", async () => {
+    const mem = ["mem1", "mem2", "mem3"];
+    const usr = ["usr1", "usr2"];
+    const { handler, notifyCalls } = await setupCommand(mem, usr);
+    const output = await invoke(handler, notifyCalls);
+
+    for (const m of mem) {
+      assert.ok(output.includes(m), `Missing memory entry: ${m}`);
+    }
+    for (const u of usr) {
+      assert.ok(output.includes(u), `Missing user entry: ${u}`);
+    }
+  });
+
+  it("entry numbering is sequential", async () => {
+    const { handler, notifyCalls } = await setupCommand(
+      ["alpha", "beta", "gamma"],
+      [],
+    );
+    const output = await invoke(handler, notifyCalls);
+
+    assert.match(output, /1\.\s*alpha/);
+    assert.match(output, /2\.\s*beta/);
+    assert.match(output, /3\.\s*gamma/);
+  });
+
+  it("unicode content renders correctly", async () => {
+    const entries = ["user loves 🍕 pizza", "works on 🚀 rockets"];
+    const { handler, notifyCalls } = await setupCommand([], entries);
+    const output = await invoke(handler, notifyCalls);
+
+    assert.ok(output.includes("🍕"));
+    assert.ok(output.includes("🚀"));
+    assert.ok(output.includes("pizza"));
+    assert.ok(output.includes("rockets"));
+  });
+});

package/dist/extensions/pi-hermes-memory/tests/handlers/interview.test.ts

@@ -0,0 +1,127 @@
+/**
+ * Unit tests for /memory-interview command.
+ */
+
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { registerInterviewCommand } from "../../src/handlers/interview.js";
+
+// ─── Mock infrastructure ───
+
+let handlers: Record<string, Function[]>;
+let notifyCalls: Array<{ msg: string; level: string }>;
+let sentMessages: string[];
+
+function createMockPi() {
+  const pi = {
+    on: () => {},
+    registerTool: () => {},
+    registerCommand: (_name: string, opts: { description: string; handler: Function }) => {
+      handlers[_name] = [{ fn: opts.handler, desc: opts.description }];
+    },
+    sendUserMessage: (text: string) => {
+      sentMessages.push(text);
+    },
+  };
+  return pi;
+}
+
+function makeMockCtx() {
+  return {
+    sessionManager: { getBranch: () => [] },
+    signal: undefined as any,
+    ui: {
+      notify: (msg: string, level: string) => {
+        notifyCalls.push({ msg, level });
+      },
+    },
+    waitForIdle: async () => {},
+  } as any;
+}
+
+const mockStore = (entries: string[]) => ({
+  getUserEntries: () => entries,
+  getMemoryEntries: () => [],
+} as any);
+
+// ─── Tests ───
+
+describe("registerInterviewCommand", () => {
+  beforeEach(() => {
+    handlers = {};
+    notifyCalls = [];
+    sentMessages = [];
+  });
+
+  it("registers the /memory-interview command", () => {
+    const pi = createMockPi();
+    registerInterviewCommand(pi as any, mockStore([]));
+
+    const cmd = handlers["memory-interview"];
+    assert.ok(cmd, "command should be registered");
+    assert.ok(cmd.length === 1, "should have one handler");
+  });
+
+  it("command description mentions onboarding", () => {
+    const pi = createMockPi();
+    registerInterviewCommand(pi as any, mockStore([]));
+
+    const cmd = handlers["memory-interview"][0];
+    assert.ok(cmd.desc.includes("user profile"), "description should mention user profile");
+  });
+
+  it("sends interview prompt as user message when USER.md is empty", async () => {
+    const pi = createMockPi();
+    registerInterviewCommand(pi as any, mockStore([]));
+
+    const ctx = makeMockCtx();
+    await handlers["memory-interview"][0].fn(undefined, ctx);
+
+    assert.strictEqual(sentMessages.length, 1, "should send one user message");
+    assert.ok(sentMessages[0].includes("onboarding interview"), "message should be the interview prompt");
+    assert.ok(sentMessages[0].includes("timezone"), "prompt should ask about timezone");
+    assert.ok(sentMessages[0].includes("work style"), "prompt should ask about work style");
+  });
+
+  it("shows notification when USER.md already has entries", async () => {
+    const pi = createMockPi();
+    const store = mockStore(["name: Chandrateja", "prefers concise answers"]);
+    registerInterviewCommand(pi as any, store);
+
+    const ctx = makeMockCtx();
+    await handlers["memory-interview"][0].fn(undefined, ctx);
+
+    assert.ok(notifyCalls.length >= 1, "should show notification for existing entries");
+    assert.ok(
+      notifyCalls[0].msg.includes("2 profile entries"),
+      "notification should mention entry count",
+    );
+    assert.ok(
+      notifyCalls[0].msg.includes("Chandrateja"),
+      "notification should show existing entry preview",
+    );
+  });
+
+  it("still sends interview prompt even when entries exist", async () => {
+    const pi = createMockPi();
+    const store = mockStore(["existing entry"]);
+    registerInterviewCommand(pi as any, store);
+
+    const ctx = makeMockCtx();
+    await handlers["memory-interview"][0].fn(undefined, ctx);
+
+    assert.strictEqual(sentMessages.length, 1, "should still send interview prompt");
+  });
+
+  it("uses correct message count grammar (1 entry)", async () => {
+    const pi = createMockPi();
+    const store = mockStore(["one entry only"]);
+    registerInterviewCommand(pi as any, store);
+
+    const ctx = makeMockCtx();
+    await handlers["memory-interview"][0].fn(undefined, ctx);
+
+    assert.ok(notifyCalls[0].msg.includes("1 profile entry"), "should use singular");
+    assert.ok(!notifyCalls[0].msg.includes("entries"), "should NOT use plural for 1 entry");
+  });
+});