llm-kb 0.2.0 → 0.4.0

package/src/trace-builder.ts

@@ -0,0 +1,168 @@
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join, basename as pathBasename } from "node:path";
+
+export interface KBTrace {
+  sessionId: string;
+  sessionFile: string;
+  timestamp: string;
+  mode: "query" | "index" | "unknown";
+  question?: string;
+  answer?: string;
+  filesRead: string[];
+  filesAvailable: string[];
+  filesSkipped: string[];
+  model?: string;
+  durationMs?: number;
+}
+
+/** Parse a session JSONL file and build a KBTrace. Returns null if session isn't complete yet. */
+export async function buildTrace(
+  sessionFile: string,
+  sourcesDir: string
+): Promise<KBTrace | null> {
+  const raw = await readFile(sessionFile, "utf-8");
+  const lines = raw.trim().split("\n").filter(Boolean);
+  if (lines.length < 2) return null;
+
+  const entries: any[] = [];
+  let header: any = null;
+  for (const line of lines) {
+    try {
+      const obj = JSON.parse(line);
+      if (obj.type === "session") header = obj;
+      else entries.push(obj);
+    } catch { /* skip malformed lines */ }
+  }
+
+  if (!header) return null;
+
+  const messages = entries.filter((e) => e.type === "message");
+  const lastAssistant = [...messages].reverse().find(
+    (e) => e.message?.role === "assistant" && e.message?.stopReason === "stop"
+  );
+  if (!lastAssistant) return null;
+
+  const modelChange = entries.find((e) => e.type === "model_change");
+  const model = modelChange?.modelId ?? lastAssistant.message?.model ?? undefined;
+
+  const firstUser = messages.find((e) => e.message?.role === "user");
+  const question = extractText(firstUser?.message?.content);
+
+  const sessionInfo = entries.find((e) => e.type === "session_info");
+  const sessionName: string = sessionInfo?.name ?? "";
+  const mode: KBTrace["mode"] = sessionName.startsWith("index:")
+    ? "index"
+    : sessionName.startsWith("query:") || question
+    ? "query"
+    : "unknown";
+
+  const answer = extractText(lastAssistant.message?.content);
+
+  const filesRead: string[] = [];
+  for (const entry of messages) {
+    if (entry.message?.role !== "assistant") continue;
+    for (const block of entry.message?.content ?? []) {
+      if (block.type === "toolCall" && block.name === "read") {
+        const p: string = block.arguments?.path ?? "";
+        if (p && !filesRead.includes(p)) filesRead.push(p);
+      }
+    }
+  }
+
+  let filesAvailable: string[] = [];
+  try {
+    const all = await readdir(sourcesDir);
+    filesAvailable = all.filter((f) => f.endsWith(".md"));
+  } catch { /* sources dir may not exist */ }
+
+  const filesSkipped = filesAvailable.filter(
+    (f) => !filesRead.some((r) => r.endsWith(f))
+  );
+
+  const firstMsg = messages[0];
+  const lastMsg = messages[messages.length - 1];
+  let durationMs: number | undefined;
+  if (firstMsg?.timestamp && lastMsg?.timestamp) {
+    durationMs = new Date(lastMsg.timestamp).getTime() - new Date(firstMsg.timestamp).getTime();
+  }
+
+  return {
+    sessionId: header.id,
+    sessionFile: pathBasename(sessionFile),
+    timestamp: header.timestamp,
+    mode,
+    question: question || undefined,
+    answer: answer || undefined,
+    filesRead,
+    filesAvailable,
+    filesSkipped,
+    model,
+    durationMs,
+  };
+}
+
+/** Write a KBTrace to .llm-kb/traces/<sessionId>.json */
+export async function saveTrace(kbRoot: string, trace: KBTrace): Promise<void> {
+  const tracesDir = join(kbRoot, ".llm-kb", "traces");
+  await mkdir(tracesDir, { recursive: true });
+  const outPath = join(tracesDir, `${trace.sessionId}.json`);
+  await writeFile(outPath, JSON.stringify(trace, null, 2) + "\n", "utf-8");
+}
+
+/** Append a query entry to .llm-kb/wiki/queries.md (newest first) */
+export async function appendToQueryLog(kbRoot: string, trace: KBTrace): Promise<void> {
+  if (trace.mode !== "query" || !trace.question) return;
+
+  const wikiDir = join(kbRoot, ".llm-kb", "wiki");
+  await mkdir(wikiDir, { recursive: true });
+  const logPath = join(wikiDir, "queries.md");
+
+  const date = new Date(trace.timestamp).toISOString().replace("T", " ").slice(0, 19);
+  const durationSec = trace.durationMs ? `${(trace.durationMs / 1000).toFixed(1)}s` : "?";
+  const filesLine = trace.filesRead.length > 0
+    ? trace.filesRead.map((f) => pathBasename(f)).join(", ")
+    : "_none_";
+
+  let header = "";
+  if (!existsSync(logPath)) {
+    header = `# Query Log\n\nAll queries run against this knowledge base.\n\n---\n\n`;
+  }
+
+  const entry = [
+    `## ${trace.question}`,
+    ``,
+    `- **Date:** ${date}`,
+    `- **Model:** ${trace.model ?? "unknown"}`,
+    `- **Duration:** ${durationSec}`,
+    `- **Files read:** ${filesLine}`,
+    trace.filesSkipped.length > 0
+      ? `- **Files skipped:** ${trace.filesSkipped.join(", ")}`
+      : null,
+    ``,
+    trace.answer ? `### Answer\n\n${trace.answer}` : null,
+    ``,
+    `---`,
+    ``,
+  ]
+    .filter((l) => l !== null)
+    .join("\n");
+
+  const existing = existsSync(logPath) ? await readFile(logPath, "utf-8") : "";
+  await writeFile(logPath, header + entry + existing, "utf-8");
+}
+
+// --- helpers ---
+
+function extractText(content: any): string {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((b) => b.type === "text")
+      .map((b) => b.text ?? "")
+      .join("")
+      .trim();
+  }
+  return "";
+}

package/src/tui-display.ts

@@ -0,0 +1,281 @@
+import {
+  TUI, Container, Spacer, Text, Markdown, ProcessTerminal,
+  type MarkdownTheme, type Component, Input,
+} from "@mariozechner/pi-tui";
+import chalk from "chalk";
+
+// ── Markdown theme ──────────────────────────────────────────────────────────
+
+function createMarkdownTheme(): MarkdownTheme {
+  return {
+    heading:         (t) => chalk.bold(t),
+    link:            (t) => chalk.cyan(t),
+    linkUrl:         (t) => chalk.dim(t),
+    code:            (t) => chalk.cyan(t),
+    codeBlock:       (t) => chalk.dim(t),
+    codeBlockBorder: (t) => chalk.dim(t),
+    quote:           (t) => chalk.italic(t),
+    quoteBorder:     (t) => chalk.dim(t),
+    hr:              (t) => chalk.dim(t),
+    listBullet:      (t) => chalk.dim(t),
+    bold:            (t) => chalk.bold(t),
+    italic:          (t) => chalk.italic(t),
+    underline:       (t) => chalk.underline(t),
+    strikethrough:   (t) => chalk.strikethrough(t),
+  };
+}
+
+const mdTheme = createMarkdownTheme();
+
+// ── Helper components ───────────────────────────────────────────────────────
+
+function dimText(text: string, px = 1, py = 0): Text {
+  return new Text(chalk.dim(text), px, py);
+}
+
+class HRule implements Component {
+  private colorFn: (s: string) => string;
+  constructor(colorFn?: (s: string) => string) {
+    this.colorFn = colorFn ?? chalk.dim;
+  }
+  invalidate() {}
+  render(width: number): string[] {
+    return [this.colorFn("\u2500".repeat(width))];
+  }
+}
+
+// ── Chat display ────────────────────────────────────────────────────────────
+//
+// All components are appended sequentially to currentResponse in the order
+// events arrive. This naturally handles interleaved thinking/tools/text:
+//
+//   ⟡ model
+//   ▸ Thinking: reasoning...
+//   Let me read the file...              ← 1st Markdown block
+//   ▸ Reading  file.md                   ← tool call (between text blocks)
+//   ──────────────────────
+//   Based on the document...             ← 2nd Markdown block
+//   ▸ Thinking: let me check another...
+//   ▸ Reading  file2.md
+//   ──────────────────────
+//   The final answer is...               ← 3rd Markdown block
+//   ── 12.3s · 2 files read ──────
+
+export class ChatDisplay {
+  private tui: TUI;
+  private terminal: ProcessTerminal;
+  private messageArea: Container;
+  private inputArea: Container;
+  private input: Input;
+
+  // Current response (reset per prompt)
+  private currentResponse: Container | null = null;
+  private currentMd: Markdown | null = null;       // active text block
+  private currentThinking: Text | null = null;      // active thinking block
+  private hadSeparator = false;                     // has a ─── line been drawn?
+
+  private filesReadCount = 0;
+  private shownToolCalls = new Set<string>();
+  private startTime = Date.now();
+
+  onSubmit?: (text: string) => void;
+  onExit?: () => void;
+
+  constructor() {
+    this.terminal = new ProcessTerminal();
+    this.tui = new TUI(this.terminal);
+
+    this.messageArea = new Container();
+    this.tui.addChild(this.messageArea);
+
+    this.inputArea = new Container();
+    this.inputArea.addChild(new HRule((s) => chalk.hex("#c678dd")(s)));
+
+    this.input = new Input();
+    this.input.onSubmit = (text) => {
+      if (text.trim() && this.onSubmit) {
+        this.addUserMessage(text.trim());
+        this.onSubmit(text.trim());
+      }
+      this.input.setValue("");
+    };
+    this.inputArea.addChild(this.input);
+    this.inputArea.addChild(new HRule((s) => chalk.hex("#c678dd")(s)));
+
+    this.tui.addChild(this.inputArea);
+    this.tui.setFocus(this.input);
+  }
+
+  start(): void {
+    this.tui.start();
+
+    this.tui.addInputListener((data) => {
+      if (data === "\x03" || data === "\x04") {
+        this.stop();
+        if (this.onExit) this.onExit();
+        else process.exit(0);
+        return { consume: true };
+      }
+      return undefined;
+    });
+
+    this.tui.requestRender();
+  }
+
+  stop(): void {
+    this.tui.stop();
+  }
+
+  addUserMessage(text: string): void {
+    this.messageArea.addChild(new Spacer(1));
+    this.messageArea.addChild(new Text(chalk.bold(text), 1, 0));
+    this.tui.requestRender();
+  }
+
+  // ── Per-prompt lifecycle (events arrive in any order) ───────────────────
+
+  beginResponse(modelName: string): void {
+    this.filesReadCount = 0;
+    this.shownToolCalls = new Set();
+    this.startTime = Date.now();
+    this.currentMd = null;
+    this.currentThinking = null;
+    this.hadSeparator = false;
+
+    this.currentResponse = new Container();
+    this.currentResponse.addChild(new Spacer(1));
+    this.currentResponse.addChild(dimText(`\u27e1 ${modelName}`));
+    this.messageArea.addChild(this.currentResponse);
+    this.tui.requestRender();
+  }
+
+  /** Start or continue a thinking block. Closes any active text block. */
+  appendThinking(text: string): void {
+    if (!this.currentResponse) return;
+
+    // Close active text block — thinking interrupts it
+    this.currentMd = null;
+
+    if (!this.currentThinking) {
+      this.currentResponse.addChild(new Spacer(1));
+      this.currentResponse.addChild(dimText("\u25b8 Thinking"));
+      this.currentThinking = new Text(chalk.dim(chalk.italic(text)), 2, 0);
+      this.currentResponse.addChild(this.currentThinking);
+    } else {
+      const prev = (this.currentThinking as any).text ?? "";
+      this.currentThinking.setText(
+        chalk.dim(chalk.italic(prev.replace(/\x1b\[[0-9;]*m/g, "") + text))
+      );
+    }
+    this.tui.requestRender();
+  }
+
+  /** End the current thinking block */
+  endThinking(): void {
+    this.currentThinking = null;
+  }
+
+  /** Add a tool call line. Closes active text block. */
+  addToolCall(toolCallId: string, label: string, toolName: string): void {
+    if (!this.currentResponse || this.shownToolCalls.has(toolCallId)) return;
+    this.shownToolCalls.add(toolCallId);
+    if (toolName === "read") this.filesReadCount++;
+
+    // Close active text block — tool call interrupts it
+    this.currentMd = null;
+
+    this.currentResponse.addChild(dimText(`  \u25b8 ${label}`));
+    this.tui.requestRender();
+  }
+
+  /** Show code block (e.g. bash script the agent wrote) */
+  addCodeBlock(code: string): void {
+    if (!this.currentResponse) return;
+    this.currentMd = null;
+    // Use Markdown component to render the code block with proper formatting
+    this.currentResponse.addChild(new Markdown("```javascript\n" + code + "\n```", 2, 0, mdTheme));
+    this.tui.requestRender();
+  }
+
+  /** Show tool execution result (success/error) */
+  addToolResult(toolCallId: string, isError: boolean): void {
+    if (!this.currentResponse) return;
+    if (isError) {
+      this.currentResponse.addChild(new Text(chalk.red("    \u2717 failed"), 0, 0));
+      this.tui.requestRender();
+    }
+  }
+
+  /** Start a NEW text block with a separator (if not the first). */
+  beginAnswer(): void {
+    if (!this.currentResponse) return;
+
+    // Close previous thinking
+    this.currentThinking = null;
+
+    // Add separator line before answer text
+    this.currentResponse.addChild(new Spacer(1));
+    this.currentResponse.addChild(new HRule());
+    this.currentResponse.addChild(new Spacer(1));
+    this.hadSeparator = true;
+
+    // Create a new Markdown block for this text segment
+    this.currentMd = new Markdown("", 1, 0, mdTheme);
+    this.currentResponse.addChild(this.currentMd);
+    this.tui.requestRender();
+  }
+
+  /** Append text to the active Markdown block (creates one if needed) */
+  appendAnswer(text: string): void {
+    if (!this.currentResponse) return;
+
+    if (!this.currentMd) {
+      // No active text block — create one (with separator if this is the first)
+      if (!this.hadSeparator) {
+        this.currentResponse.addChild(new Spacer(1));
+        this.currentResponse.addChild(new HRule());
+        this.currentResponse.addChild(new Spacer(1));
+        this.hadSeparator = true;
+      }
+      this.currentMd = new Markdown("", 1, 0, mdTheme);
+      this.currentResponse.addChild(this.currentMd);
+    }
+
+    const prev = (this.currentMd as any).text ?? "";
+    this.currentMd.setText(prev + text);
+    this.tui.requestRender();
+  }
+
+  showCompletion(): void {
+    if (!this.currentResponse) return;
+    const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+    const source = this.filesReadCount > 0
+      ? `${this.filesReadCount} file${this.filesReadCount !== 1 ? "s" : ""} read`
+      : "wiki";
+    const stats = `\u2500\u2500 ${elapsed}s \u00b7 ${source} `;
+
+    const completion: Component = {
+      invalidate() {},
+      render(width: number) {
+        const pad = Math.max(0, width - stats.length);
+        return [chalk.dim(stats + "\u2500".repeat(pad))];
+      },
+    };
+
+    this.currentResponse.addChild(new Spacer(1));
+    this.currentResponse.addChild(completion);
+    this.currentResponse = null;
+    this.currentMd = null;
+    this.currentThinking = null;
+    this.tui.requestRender();
+  }
+
+  enableInput(): void {
+    this.tui.setFocus(this.input);
+    this.tui.requestRender();
+  }
+
+  disableInput(): void {
+    this.tui.setFocus(null);
+  }
+}

package/src/utils.ts

@@ -0,0 +1,17 @@
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Find the node_modules directory for llm-kb's bundled libraries.
+ * Walks up from the current file to locate the nearest node_modules.
+ */
+export function getNodeModulesPath(): string {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = join(dir, "node_modules");
+    try { return candidate; } catch { dir = dirname(dir); }
+  }
+  return join(process.cwd(), "node_modules");
+}

package/src/watcher.ts

@@ -2,15 +2,18 @@ import { watch } from "chokidar";
 import { extname, join, basename } from "node:path";
 import { parsePDF } from "./pdf.js";
 import { buildIndex } from "./indexer.js";
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
 import chalk from "chalk";
 
 interface WatcherOptions {
   folder: string;
   sourcesDir: string;
   debounceMs?: number;
+  authStorage?: AuthStorage;
+  indexModel?: string;
 }
 
-export function startWatcher({ folder, sourcesDir, debounceMs = 2000 }: WatcherOptions) {
+export function startWatcher({ folder, sourcesDir, debounceMs = 2000, authStorage, indexModel }: WatcherOptions) {
   let pendingFiles: string[] = [];
   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
 
@@ -39,7 +42,7 @@ export function startWatcher({ folder, sourcesDir, debounceMs = 2000 }: WatcherO
     // Re-index
     process.stdout.write(`  Re-indexing...`);
     try {
-      await buildIndex(folder, sourcesDir);
+      await buildIndex(folder, sourcesDir, undefined, authStorage, indexModel);
       console.log(chalk.green(` ✓ index.md updated`));
     } catch (err: any) {
       console.log(chalk.red(` ✗ ${err.message}`));

package/src/wiki-updater.ts

@@ -0,0 +1,136 @@
+import { getModels, completeSimple } from "@mariozechner/pi-ai";
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { KBTrace } from "./trace-builder.js";
+
+async function resolveApiKey(authStorage?: AuthStorage): Promise<string | undefined> {
+  if (authStorage) {
+    return authStorage.getApiKey("anthropic");
+  }
+  const piAuthPath = join(homedir(), ".pi", "agent", "auth.json");
+  if (existsSync(piAuthPath)) {
+    const storage = AuthStorage.create(piAuthPath);
+    return storage.getApiKey("anthropic");
+  }
+  return process.env.ANTHROPIC_API_KEY;
+}
+
+function buildPrompt(
+  question: string,
+  answer: string,
+  sources: string,
+  date: string,
+  currentWiki: string
+): string {
+  const rules = `Rules for wiki structure:
+- Use ## for CONCEPTS and TOPICS — NOT source file names
+  Good: "## Electronic Evidence", "## Mob Lynching", "## Burden of Proof"
+  Bad: "## Indian Evidence Act.md", "## indian penal code - new.md"
+- Use ### for subtopics within a concept
+- A concept can draw from MULTIPLE source files — synthesize, don't separate by file
+- If knowledge from this Q&A fits an existing concept, ADD to it — never duplicate
+- If it's a genuinely new concept, create a new ## section
+- Be concise: bullet points for lists, short prose for explanations
+- Include source citations inline: (Source: filename, p.X)
+- Add cross-references where concepts relate: See also: [[Other Concept]]
+- End each ## section with: *Sources: file1, file2 · date*
+- Separate ## sections with: ---`;
+
+  if (currentWiki.trim()) {
+    return `You are maintaining a concept-organized knowledge wiki.
+
+## Current wiki
+${currentWiki}
+
+## New Q&A to integrate
+**Question:** ${question}
+**Sources used:** ${sources}
+**Date:** ${date}
+
+**Answer:**
+${answer}
+
+---
+
+Update the wiki to integrate this new knowledge.
+${rules}
+
+Return ONLY the complete updated wiki markdown. No explanation.`;
+  }
+
+  return `You are creating a concept-organized knowledge wiki.
+
+## First Q&A to add
+**Question:** ${question}
+**Sources used:** ${sources}
+**Date:** ${date}
+
+**Answer:**
+${answer}
+
+---
+
+Create a clean wiki from this Q&A.
+- Start with: # Knowledge Wiki\\n\\n> Concept-organized knowledge base. Updated after each query.\\n\\n---
+${rules}
+
+Return ONLY the wiki markdown. No explanation.`;
+}
+
+/**
+ * Update .llm-kb/wiki/wiki.md using a direct Haiku call.
+ * Organizes knowledge by CONCEPT (cross-cutting topics),
+ * not by source file.
+ */
+export async function updateWiki(
+  kbRoot: string,
+  trace: KBTrace,
+  authStorage?: AuthStorage,
+  indexModelId = "claude-haiku-4-5"
+): Promise<void> {
+  if (trace.mode !== "query" || !trace.question || !trace.answer) return;
+
+  const wikiDir = join(kbRoot, ".llm-kb", "wiki");
+  await mkdir(wikiDir, { recursive: true });
+  const wikiPath = join(wikiDir, "wiki.md");
+
+  const currentWiki = existsSync(wikiPath)
+    ? await readFile(wikiPath, "utf-8").catch(() => "")
+    : "";
+
+  const sources = trace.filesRead
+    .map((f) => f.split(/[\\/]/).pop() ?? f)
+    .filter((f) => f.endsWith(".md") && f !== "index.md" && f !== "wiki.md")
+    .join(", ") || "unknown";
+
+  const date = new Date(trace.timestamp).toISOString().slice(0, 10);
+  const prompt = buildPrompt(trace.question, trace.answer, sources, date, currentWiki);
+
+  const apiKey = await resolveApiKey(authStorage);
+  if (!apiKey) return;
+
+  const model = getModels("anthropic").find((m) => m.id === indexModelId);
+  if (!model) return;
+
+  const result = await completeSimple(
+    model,
+    {
+      systemPrompt: "You are a precise knowledge librarian. Organize information by CONCEPT, not by source file. Synthesize knowledge from multiple sources into unified topic articles. Return only clean markdown.",
+      messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+    },
+    { apiKey }
+  );
+
+  const text = result.content
+    .filter((b) => b.type === "text")
+    .map((b) => (b as any).text)
+    .join("")
+    .trim();
+
+  if (text) {
+    await writeFile(wikiPath, text + "\n", "utf-8");
+  }
+}

package/test/auth.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+// Mock existsSync before importing auth module
+vi.mock("node:fs", async () => {
+  const actual = await vi.importActual<typeof import("node:fs")>("node:fs");
+  return { ...actual, existsSync: vi.fn() };
+});
+
+import { checkAuth } from "../src/auth.js";
+import { existsSync } from "node:fs";
+
+const mockExistsSync = vi.mocked(existsSync);
+
+describe("checkAuth", () => {
+  const origEnv = process.env.ANTHROPIC_API_KEY;
+
+  afterEach(() => {
+    if (origEnv !== undefined) process.env.ANTHROPIC_API_KEY = origEnv;
+    else delete process.env.ANTHROPIC_API_KEY;
+    vi.restoreAllMocks();
+  });
+
+  it("returns pi-sdk when auth.json exists", () => {
+    mockExistsSync.mockReturnValue(true);
+    delete process.env.ANTHROPIC_API_KEY;
+
+    const result = checkAuth();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.method).toBe("pi-sdk");
+      expect(result.authStorage).toBeUndefined(); // uses default
+    }
+  });
+
+  it("returns api-key when ANTHROPIC_API_KEY is set", () => {
+    mockExistsSync.mockReturnValue(false);
+    process.env.ANTHROPIC_API_KEY = "sk-ant-test";
+
+    const result = checkAuth();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.method).toBe("api-key");
+      expect(result.authStorage).toBeDefined();
+    }
+  });
+
+  it("returns failure when neither is available", () => {
+    mockExistsSync.mockReturnValue(false);
+    delete process.env.ANTHROPIC_API_KEY;
+
+    const result = checkAuth();
+    expect(result.ok).toBe(false);
+  });
+
+  it("prefers pi-sdk over api-key when both exist", () => {
+    mockExistsSync.mockReturnValue(true);
+    process.env.ANTHROPIC_API_KEY = "sk-ant-test";
+
+    const result = checkAuth();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.method).toBe("pi-sdk");
+    }
+  });
+});