@jaggerxtrm/pi-extensions 0.9.4 → 0.9.5

package/extensions/xtprompt/index.test.ts

@@ -0,0 +1,496 @@
+import { describe, expect, mock, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const completeCalls: unknown[][] = [];
+let completeImpl: (...args: unknown[]) => Promise<unknown> = async () => null;
+
+mock.module("@earendil-works/pi-ai", () => ({
+  complete: async (...args: unknown[]) => {
+    completeCalls.push(args);
+    return completeImpl(...args);
+  },
+}));
+
+mock.module("@earendil-works/pi-coding-agent", () => ({
+  BorderedLoader: class {
+    signal = new AbortController().signal;
+    onAbort?: () => void;
+  },
+  VERSION: "test",
+  createBashTool: () => ({}),
+  createEditTool: () => ({}),
+  createFindTool: () => ({}),
+  createGrepTool: () => ({}),
+  createLsTool: () => ({}),
+  createReadTool: () => ({}),
+  createWriteTool: () => ({}),
+  isBashToolResult: () => false,
+  isToolCallEventType: () => false,
+}));
+
+mock.module("@earendil-works/pi-tui", () => ({
+  Box: () => null,
+  Text: () => null,
+  matchesKey: () => false,
+  truncateToWidth: (value: string) => value,
+  visibleWidth: (value: string) => value.length,
+}));
+
+for (const modulePath of [
+  "../../src/extensions/auto-session-name.ts",
+  "../../src/extensions/auto-update.ts",
+  "../../src/extensions/beads.ts",
+  "../../src/extensions/compact-header.ts",
+  "../../src/extensions/custom-footer.ts",
+  "../../src/extensions/custom-provider-qwen-cli.ts",
+  "../../src/extensions/git-checkpoint.ts",
+  "../../src/extensions/lsp-bootstrap.ts",
+  "../../src/extensions/quality-gates.ts",
+  "../../src/extensions/serena-pool.ts",
+  "../../src/extensions/service-skills.ts",
+  "../../src/extensions/session-flow.ts",
+  "../../src/extensions/sp-terminal-overlay.ts",
+  "../../src/extensions/xtrm-loader.ts",
+  "../../src/extensions/xtrm-ui.ts",
+]) {
+  mock.module(modulePath, () => ({
+    default() {},
+  }));
+}
+
+const xtprompt = await import("./index.ts");
+
+function registerExtensionHandlers() {
+  const commandHandlers = new Map<string, (args: string, ctx: any) => Promise<void>>();
+  const shortcuts: Array<{ key: string; description: string; handler: (ctx: any) => Promise<void> }> = [];
+
+  xtprompt.default({
+    registerShortcut(key: string, config: { description: string; handler: (ctx: any) => Promise<void> }) {
+      shortcuts.push({ key, ...config });
+    },
+    registerCommand(name: string, config: { handler: (args: string, ctx: any) => Promise<void>; description: string }) {
+      commandHandlers.set(name, config.handler);
+    },
+  });
+
+  return { commandHandlers, shortcuts };
+}
+
+describe("xtprompt", () => {
+  test("detects vague drafts", () => {
+    expect(xtprompt.isVagueDraft("help")).toBe(true);
+    expect(xtprompt.isVagueDraft("fix this")).toBe(true);
+    expect(xtprompt.isVagueDraft("help me improve this prompt today")).toBe(true);
+    expect(
+      xtprompt.isVagueDraft(
+        "Update packages/pi-extensions/extensions/xtprompt/index.ts to rename command to /xtprompt.",
+      ),
+    ).toBe(false);
+  });
+
+  test("clarification merge keeps original draft concrete", () => {
+    const merged = xtprompt.buildClarifiedDraft(
+      "help",
+      "Need rewrite for planning prompt in packages/pi-extensions/extensions/xtprompt/index.ts",
+    );
+    expect(merged).toContain("Original draft:");
+    expect(merged).toContain("Clarification:");
+  });
+
+  test("conversation extraction prefers recent wrapped messages and uses summary fallback", () => {
+    const context = xtprompt.extractConversationContext([
+      { message: { role: "tool", content: "ignored" } },
+      { message: { role: "assistant", content: [{ type: "tool-call", text: "ignored" }] } },
+      { message: { role: "user", content: "Need generic xtprompt rewrite" } },
+      { message: { role: "assistant", content: [{ type: "text", text: "Will preserve current draft" }] } },
+      { summary: "Compaction summary: old summary fallback" },
+    ]);
+    expect(context).toContain("Need generic xtprompt rewrite");
+    expect(context).toContain("Will preserve current draft");
+    expect(context).not.toContain("Compaction summary");
+    expect(context).not.toContain("tool-call");
+  });
+
+  test("conversation extraction falls back to summary and caps by chars", () => {
+    const context = xtprompt.extractConversationContext(
+      [
+        { message: { role: "tool", content: "ignored" } },
+        { summary: "Compaction summary: user wants generic xtprompt rewrite" },
+      ],
+      2,
+      48,
+    );
+    expect(context).toContain("Compaction summary");
+    expect(context.length).toBeLessThanOrEqual(48);
+
+    const oversizedSummary = xtprompt.extractConversationContext(
+      [
+        { message: { role: "tool", content: "ignored" } },
+        { summary: "Compaction summary: user wants generic xtprompt rewrite with much longer retained context than limit allows" },
+      ],
+      2,
+      24,
+    );
+    expect(oversizedSummary).toBe("Compaction summary: user");
+    expect(oversizedSummary.length).toBeLessThanOrEqual(24);
+
+    const bounded = xtprompt.extractConversationContext(
+      [
+        { message: { role: "user", content: "first" } },
+        { message: { role: "assistant", content: "second" } },
+        { message: { role: "user", content: "third message much longer than limit" } },
+      ],
+      3,
+      20,
+    );
+    expect(bounded).not.toContain("first");
+    expect(bounded).not.toContain("second");
+    expect(bounded.length).toBeLessThanOrEqual(20);
+  });
+
+  test("planning requests include substantive planning guidance", () => {
+    const request = xtprompt.buildPromptRequest({
+      draft: "Plan rewrite for prompt with ## PROBLEM and ## SUCCESS",
+      intent: xtprompt.detectIntent("Plan rewrite for prompt with ## PROBLEM and ## SUCCESS"),
+      conversationContext: "",
+    });
+    expect(request.systemPrompt).toContain("<output_format>");
+    expect(request.systemPrompt).toContain("## PROBLEM");
+    expect(request.systemPrompt).toContain("GitNexus or Serena");
+    expect(request.systemPrompt).toContain("phases, dependencies, parallel work, risks, and blast radius");
+    expect(request.systemPrompt).toContain("telemetry, smoke coverage, E2E checks");
+  });
+
+  test("simple request can stay concise while complex request uses semantic xml", () => {
+    const simple = xtprompt.buildPromptRequest({
+      draft: "Rename command to /xtprompt",
+      intent: xtprompt.detectIntent("Rename command to /xtprompt"),
+      conversationContext: "",
+    });
+    const complex = xtprompt.buildPromptRequest({
+      draft:
+        "Implement generic contextual xtprompt rewrite with planning sections, prior chat context, sentinel parsing, clarification flow, and auth forwarding.",
+      intent: xtprompt.detectIntent(
+        "Implement generic contextual xtprompt rewrite with planning sections, prior chat context, sentinel parsing, clarification flow, and auth forwarding.",
+      ),
+      conversationContext: "recent user asked for standalone rewrite </context><pwned>",
+    });
+    expect(simple.systemPrompt.includes("<role>")).toBeFalse();
+    expect(complex.systemPrompt).toContain("<role>");
+    expect(complex.systemPrompt).toContain("recent user asked");
+    expect(complex.systemPrompt).toContain("&lt;/context&gt;&lt;pwned&gt;");
+    expect(complex.systemPrompt).not.toContain("recent user asked for standalone rewrite </context><pwned>");
+  });
+
+  test("structured prompt escapes raw xml closing tags and entities inside context block", () => {
+    const request = xtprompt.buildPromptRequest({
+      draft:
+        "Implement generic contextual xtprompt rewrite with planning sections, prior chat context, sentinel parsing, clarification flow, auth forwarding, constraints, validation, and output expectations.",
+      intent: "development",
+      conversationContext: `danger </context> & \"quote\" 'apos'`,
+    });
+
+    expect(request.systemPrompt).toContain("<context>\ndanger &lt;/context&gt; &amp; &quot;quote&quot; &apos;apos&apos;\n</context>");
+    expect(request.systemPrompt).not.toContain("<context>\ndanger </context>");
+  });
+
+  test("intent selection covers planning, analysis, development, refactor, generic", () => {
+    expect(xtprompt.detectIntent("Need plan with ## PROBLEM and ## SCOPE")).toBe("planning");
+    expect(xtprompt.detectIntent("Analyze failing sentinel parse")).toBe("analysis");
+    expect(xtprompt.detectIntent("Implement auth forwarding")).toBe("development");
+    expect(xtprompt.detectIntent("Refactor command registration")).toBe("refactor");
+    expect(xtprompt.detectIntent("Tighten prompt wording")).toBe("generic");
+  });
+
+  test("intent-specific guidance stays substantive", () => {
+    const analysis = xtprompt.buildPromptRequest({
+      draft: "Analyze failing sentinel parse in xtprompt with prior chat, competing hypotheses, escaped context, and validation expectations.",
+      intent: "analysis",
+      conversationContext: "",
+    });
+    const development = xtprompt.buildPromptRequest({
+      draft: "Implement auth forwarding for xtprompt with explicit success criteria, verification steps, grounded examples, and output expectations.",
+      intent: "development",
+      conversationContext: "",
+    });
+    const refactor = xtprompt.buildPromptRequest({
+      draft: "Refactor xtprompt request building while preserving behavior, constraints, touched tests, and validation requirements across current state.",
+      intent: "refactor",
+      conversationContext: "",
+    });
+
+    expect(analysis.systemPrompt).toContain("Name evidence, open questions, hypotheses, and validation steps before recommendations");
+    expect(development.systemPrompt).toContain("Make success criteria and testing explicit");
+    expect(development.systemPrompt).toContain("1-2 grounded examples only when they materially improve execution");
+    expect(refactor.systemPrompt).toContain("State current state, preserved behavior, constraints, touched tests, and validation");
+  });
+
+  test("sentinel parsing extracts xtprompt block", () => {
+    expect(xtprompt.parseSentinel("prefix<xtprompt>done</xtprompt>suffix")).toBe("done");
+    expect(xtprompt.parseSentinel("missing")).toBeUndefined();
+  });
+
+  test("registers canonical xtprompt command and shortcut", () => {
+    const registeredCommands: Array<{ name: string; description: string }> = [];
+    const registeredShortcuts: Array<{ key: string; description: string }> = [];
+
+    xtprompt.default({
+      registerShortcut(key: string, config: { description: string }) {
+        registeredShortcuts.push({ key, description: config.description });
+      },
+      registerCommand(name: string, config: { description: string }) {
+        registeredCommands.push({ name, description: config.description });
+      },
+    } as any);
+
+    expect(registeredCommands).toEqual([
+      { name: "xtprompt", description: "xtprompt: rewrite current editor prompt" },
+    ]);
+    expect(registeredShortcuts).toEqual([
+      { key: "alt+m", description: "Rewrite current editor draft (xtprompt)" },
+    ]);
+  });
+
+  test("cancelled clarification leaves editor unchanged and skips model call", async () => {
+    completeCalls.length = 0;
+    completeImpl = async () => {
+      throw new Error("complete should not run");
+    };
+
+    let editorText = "help";
+    const { commandHandlers } = registerExtensionHandlers();
+    const handler = commandHandlers.get("xtprompt");
+    expect(handler).toBeDefined();
+
+    await handler!("", {
+      hasUI: true,
+      mode: "tui",
+      model: { maxTokens: 1024 },
+      ui: {
+        notify() {},
+        getEditorText: () => editorText,
+        setEditorText: (value: string) => {
+          editorText = value;
+        },
+        input: async () => null,
+      },
+      modelRegistry: {
+        getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k" }),
+      },
+      sessionManager: { buildContextEntries: () => [] },
+    });
+
+    expect(editorText).toBe("help");
+    expect(completeCalls).toHaveLength(0);
+  });
+
+  test("forwards resolved auth env to complete", async () => {
+    completeCalls.length = 0;
+    completeImpl = async () => ({
+      content: [{ type: "text", text: "<xtprompt>done</xtprompt>" }],
+    });
+
+    let editorText = "Rename command to /xtprompt in packages/pi-extensions/extensions/xtprompt/index.ts";
+    const { commandHandlers } = registerExtensionHandlers();
+
+    await commandHandlers.get("xtprompt")!("", {
+      hasUI: true,
+      mode: "tui",
+      model: { maxTokens: 1024 },
+      ui: {
+        notify() {},
+        getEditorText: () => editorText,
+        setEditorText: (value: string) => {
+          editorText = value;
+        },
+        custom: async (render: (tui: unknown, theme: unknown, keybindings: unknown, done: (value: string | null) => void) => unknown) =>
+          await new Promise<string | null>((resolve) => {
+            render({}, {}, {}, resolve);
+          }),
+      },
+      modelRegistry: {
+        getApiKeyAndHeaders: async () => ({
+          ok: true,
+          apiKey: "key-1",
+          headers: { authorization: "Bearer x" },
+          env: { RESOLVED_AUTH: "yes" },
+        }),
+      },
+      sessionManager: { buildContextEntries: () => [] },
+    });
+
+    expect(editorText).toBe("done");
+    const [, , options] = completeCalls[0] as [unknown, unknown, Record<string, unknown>];
+    expect(options.apiKey).toBe("key-1");
+    expect(options.headers).toEqual({ authorization: "Bearer x" });
+    expect(options.env).toEqual({ RESOLVED_AUTH: "yes" });
+  });
+
+  test("auth rejection leaves editor unchanged and skips model call", async () => {
+    completeCalls.length = 0;
+    completeImpl = async () => {
+      throw new Error("complete should not run");
+    };
+
+    const notices: Array<{ message: string; level: string }> = [];
+    let editorText = "Rename command to /xtprompt in packages/pi-extensions/extensions/xtprompt/index.ts";
+    const { commandHandlers } = registerExtensionHandlers();
+
+    await commandHandlers.get("xtprompt")!("", {
+      hasUI: true,
+      mode: "tui",
+      model: { maxTokens: 1024 },
+      ui: {
+        notify(message: string, level: string) {
+          notices.push({ message, level });
+        },
+        getEditorText: () => editorText,
+        setEditorText: (value: string) => {
+          editorText = value;
+        },
+        custom: async () => {
+          throw new Error("loader should stay unused on auth rejection");
+        },
+      },
+      modelRegistry: {
+        getApiKeyAndHeaders: async () => ({ ok: false, error: "RPC unavailable" }),
+      },
+      sessionManager: { buildContextEntries: () => [] },
+    });
+
+    expect(editorText).toBe("Rename command to /xtprompt in packages/pi-extensions/extensions/xtprompt/index.ts");
+    expect(completeCalls).toHaveLength(0);
+    expect(notices).toContainEqual({ message: "xtprompt: cannot resolve auth — RPC unavailable", level: "error" });
+  });
+
+  test("rpc mode guard rejects before touching editor, loader, model registry, or complete", async () => {
+    completeCalls.length = 0;
+    completeImpl = async () => {
+      throw new Error("complete should not run");
+    };
+
+    const notices: Array<{ message: string; level: string }> = [];
+    const getEditorText = mock(() => "Rename command to /xtprompt in packages/pi-extensions/extensions/xtprompt/index.ts");
+    const setEditorText = mock((_value: string) => {});
+    const custom = mock(async () => {
+      throw new Error("loader should stay unused in rpc mode");
+    });
+    const getApiKeyAndHeaders = mock(async () => ({ ok: true, apiKey: "k" }));
+    const { commandHandlers } = registerExtensionHandlers();
+
+    await commandHandlers.get("xtprompt")!("", {
+      hasUI: true,
+      mode: "rpc",
+      model: { maxTokens: 1024 },
+      ui: {
+        notify(message: string, level: string) {
+          notices.push({ message, level });
+        },
+        getEditorText,
+        setEditorText,
+        custom,
+      },
+      modelRegistry: {
+        getApiKeyAndHeaders,
+      },
+      sessionManager: { buildContextEntries: () => [] },
+    });
+
+    expect(getEditorText).toHaveBeenCalledTimes(0);
+    expect(setEditorText).toHaveBeenCalledTimes(0);
+    expect(custom).toHaveBeenCalledTimes(0);
+    expect(getApiKeyAndHeaders).toHaveBeenCalledTimes(0);
+    expect(completeCalls).toHaveLength(0);
+    expect(notices).toContainEqual({ message: "xtprompt needs TUI mode.", level: "error" });
+  });
+
+  test("clarification path forwards merged draft, session context, and avoids main-session send", async () => {
+    completeCalls.length = 0;
+    completeImpl = async () => ({
+      content: [{ type: "text", text: "<xtprompt>done</xtprompt>" }],
+    });
+
+    let editorText = "help me improve this prompt today";
+    const send = mock(() => {
+      throw new Error("main session send should stay unused");
+    });
+    const { commandHandlers } = registerExtensionHandlers();
+
+    await commandHandlers.get("xtprompt")!("", {
+      hasUI: true,
+      mode: "tui",
+      model: { maxTokens: 1024 },
+      send,
+      ui: {
+        notify() {},
+        getEditorText: () => editorText,
+        setEditorText: (value: string) => {
+          editorText = value;
+        },
+        input: async () => "Need rewrite for /xtprompt planning contract in packages/pi-extensions/extensions/xtprompt/index.ts",
+        custom: async (
+          render: (tui: unknown, theme: unknown, keybindings: unknown, done: (value: string | null) => void) => unknown,
+        ) =>
+          await new Promise<string | null>((resolve) => {
+            render({}, {}, {}, resolve);
+          }),
+      },
+      modelRegistry: {
+        getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k" }),
+      },
+      sessionManager: {
+        buildContextEntries: () => [
+          { message: { role: "user", content: "Need post-diff xtprompt audit" } },
+          { message: { role: "assistant", content: [{ type: "text", text: "Protect critical paths only" }] } },
+          { summary: "older compacted summary" },
+        ],
+      },
+    });
+
+    expect(editorText).toBe("done");
+    expect(send).toHaveBeenCalledTimes(0);
+    const [, request] = completeCalls[0] as [unknown, { messages: Array<{ content: string }>; systemPrompt: string }];
+    expect(request.messages[0]?.content).toContain("Original draft: help me improve this prompt today");
+    expect(request.messages[0]?.content).toContain("Clarification: Need rewrite for /xtprompt planning contract");
+    expect(request.systemPrompt).toContain("Need post-diff xtprompt audit");
+    expect(request.systemPrompt).toContain("Protect critical paths only");
+    expect(request.systemPrompt).not.toContain("older compacted summary");
+  });
+
+  test("managed registry smoke registers xtprompt command without agent send", async () => {
+    completeCalls.length = 0;
+    const send = mock(() => {
+      throw new Error("main agent send should stay unused");
+    });
+    const { registerManagedPiExtensions } = await import("../../src/registry.ts");
+    const commands = new Map<string, { description: string }>();
+
+    registerManagedPiExtensions({
+      send,
+      registerCommand(name: string, config: { description: string }) {
+        commands.set(name, { description: config.description });
+      },
+      registerShortcut() {},
+    } as any);
+
+    expect(commands.get("xtprompt")).toEqual({ description: "xtprompt: rewrite current editor prompt" });
+    expect(send).toHaveBeenCalledTimes(0);
+    expect(completeCalls).toHaveLength(0);
+  });
+
+  test("shipped xtprompt files contain no legacy project branding", () => {
+    const forbiddenTokens = [
+      [["merc", "ury"].join(""), "-smith"].join(""),
+      ["/", "m", "smith"].join(""),
+      ["m", "m", "d"].join(""),
+    ];
+
+    for (const file of ["index.ts", "package.json"]) {
+      const content = readFileSync(join("packages/pi-extensions/extensions/xtprompt", file), "utf8").toLowerCase();
+      for (const forbiddenToken of forbiddenTokens) {
+        expect(content.includes(forbiddenToken)).toBe(false);
+      }
+    }
+  });
+});