claude-session-skill 1.1.0

package/lib/__tests__/indexer.test.ts

@@ -0,0 +1,176 @@
+import { describe, test, expect } from "bun:test";
+import { isTopical, shortProject, decodeProjectDir, extractConversation, isGarbageSummary } from "../indexer";
+
+describe("isTopical", () => {
+  test("rejects short messages", () => {
+    expect(isTopical("hi")).toBe(false);
+    expect(isTopical("")).toBe(false);
+    expect(isTopical("abcd")).toBe(false);
+  });
+
+  test("rejects slash commands", () => {
+    expect(isTopical("/session list")).toBe(false);
+    expect(isTopical("/help")).toBe(false);
+  });
+
+  test("rejects XML-like messages", () => {
+    expect(isTopical("<system-reminder>...")).toBe(false);
+  });
+
+  test("rejects MEMORY prefixed messages", () => {
+    expect(isTopical("[MEMORY] saved")).toBe(false);
+  });
+
+  test("accepts normal user messages", () => {
+    expect(isTopical("Fix the login bug")).toBe(true);
+    expect(isTopical("What does this function do?")).toBe(true);
+    expect(isTopical("Hello world")).toBe(true);
+  });
+
+  test("accepts messages exactly at length threshold", () => {
+    expect(isTopical("abcde")).toBe(true);
+  });
+});
+
+describe("shortProject", () => {
+  const HOME = process.env.HOME!;
+
+  test("returns ~ for empty or home directory", () => {
+    expect(shortProject("")).toBe("~");
+    expect(shortProject(HOME)).toBe("~");
+  });
+
+  test("strips home prefix", () => {
+    expect(shortProject(`${HOME}/projects/my-app`)).toBe("projects/my-app");
+  });
+
+  test("returns full path for non-home paths", () => {
+    expect(shortProject("/var/www/app")).toBe("/var/www/app");
+  });
+});
+
+describe("decodeProjectDir", () => {
+  test("decodes standard project directory names", () => {
+    expect(decodeProjectDir("-Users-tim")).toBe("/Users/tim");
+    expect(decodeProjectDir("-home-user-projects")).toBe("/home/user/projects");
+  });
+
+  test("handles leading dash removal", () => {
+    const decoded = decodeProjectDir("-Users-tim-code");
+    expect(decoded.startsWith("/")).toBe(true);
+    expect(decoded).toBe("/Users/tim/code");
+  });
+});
+
+describe("isGarbageSummary", () => {
+  test("detects empty summaries", () => {
+    expect(isGarbageSummary("")).toBe(true);
+  });
+
+  test("detects refusal responses", () => {
+    expect(isGarbageSummary("I don't have access to the transcript")).toBe(true);
+    expect(isGarbageSummary("I don't see any conversation")).toBe(true);
+    expect(isGarbageSummary("I'm afraid I can't summarize")).toBe(true);
+    expect(isGarbageSummary("I cannot provide a summary")).toBe(true);
+  });
+
+  test("detects format echoing", () => {
+    expect(isGarbageSummary("(80 chars max) something")).toBe(true);
+  });
+
+  test("accepts valid summaries", () => {
+    expect(isGarbageSummary("- Fixed authentication bug in login flow")).toBe(false);
+    expect(isGarbageSummary("- Built session indexer with search")).toBe(false);
+  });
+});
+
+describe("extractConversation", () => {
+  function makeLine(type: string, role: string, content: string, isMeta = false): string {
+    return JSON.stringify({
+      type,
+      isMeta,
+      message: { role, content },
+    });
+  }
+
+  test("extracts user messages", () => {
+    const text = makeLine("user", "user", "Fix the login bug please");
+    const result = extractConversation(text);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toStartWith("USER:");
+    expect(result[0]).toContain("Fix the login bug");
+  });
+
+  test("extracts assistant messages", () => {
+    const text = makeLine("assistant", "assistant", "I'll fix that bug by updating the auth handler to check for expired tokens.");
+    const result = extractConversation(text);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toStartWith("ASSISTANT:");
+  });
+
+  test("skips meta messages", () => {
+    const text = makeLine("user", "user", "some meta content", true);
+    const result = extractConversation(text);
+    expect(result).toHaveLength(0);
+  });
+
+  test("skips non-topical messages", () => {
+    const text = makeLine("user", "user", "/help");
+    const result = extractConversation(text);
+    expect(result).toHaveLength(0);
+  });
+
+  test("respects maxMessages limit by taking last N", () => {
+    const lines = Array.from({ length: 10 }, (_, i) =>
+      makeLine("user", "user", `Message number ${i} is here`)
+    ).join("\n");
+    const result = extractConversation(lines, 3);
+    expect(result).toHaveLength(3);
+    // Should take the LAST 3 messages
+    expect(result[2]).toContain("Message number 9");
+  });
+
+  test("handles malformed JSONL gracefully", () => {
+    const text = [
+      "{invalid json",
+      makeLine("user", "user", "Valid message here"),
+      "not json at all",
+    ].join("\n");
+    const result = extractConversation(text);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toContain("Valid message");
+  });
+
+  test("handles empty input", () => {
+    expect(extractConversation("")).toHaveLength(0);
+    expect(extractConversation("\n\n\n")).toHaveLength(0);
+  });
+
+  test("truncates long user messages to 300 chars", () => {
+    const longMsg = "x".repeat(500);
+    const text = makeLine("user", "user", longMsg);
+    const result = extractConversation(text);
+    expect(result[0].length).toBeLessThanOrEqual(306);
+  });
+
+  test("handles assistant messages with content blocks", () => {
+    const text = JSON.stringify({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Here is a detailed explanation of how the function works and why it needs fixing." },
+        ],
+      },
+    });
+    const result = extractConversation(text);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toStartWith("ASSISTANT:");
+  });
+
+  test("skips short assistant messages", () => {
+    const text = makeLine("assistant", "assistant", "OK");
+    const result = extractConversation(text);
+    expect(result).toHaveLength(0);
+  });
+});

package/lib/__tests__/search.test.ts

@@ -0,0 +1,135 @@
+import { describe, test, expect } from "bun:test";
+import { searchSessions } from "../search";
+import type { SessionEntry } from "../indexer";
+
+function makeSession(overrides: Partial<SessionEntry> = {}): SessionEntry {
+  return {
+    id: "test-" + Math.random().toString(36).slice(2, 10),
+    name: "",
+    project: "",
+    projectDir: "",
+    topic: "",
+    firstMessage: "",
+    lastMessage: "",
+    allMessages: "",
+    messageCount: 1,
+    firstTimestamp: Date.now() - 86400000 * 7,
+    lastTimestamp: Date.now() - 86400000 * 7,
+    cwd: "",
+    gitBranch: "",
+    ...overrides,
+  };
+}
+
+describe("searchSessions", () => {
+  test("returns empty array for no matches", () => {
+    const sessions = [makeSession({ topic: "fix login bug" })];
+    const results = searchSessions(sessions, "deploy");
+    expect(results).toHaveLength(0);
+  });
+
+  test("returns all sessions for empty query tokens", () => {
+    const sessions = [
+      makeSession({ topic: "fix login" }),
+      makeSession({ topic: "add feature" }),
+    ];
+    const results = searchSessions(sessions, "a");
+    expect(results).toHaveLength(2);
+  });
+
+  test("matches on topic", () => {
+    const sessions = [
+      makeSession({ id: "a", topic: "deploy pipeline setup" }),
+      makeSession({ id: "b", topic: "unrelated work" }),
+    ];
+    const results = searchSessions(sessions, "deploy");
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe("a");
+  });
+
+  test("ranks name matches highest", () => {
+    const sessions = [
+      makeSession({ id: "a", name: "", topic: "deploy pipeline" }),
+      makeSession({ id: "b", name: "Deploy Fix", topic: "unrelated" }),
+    ];
+    const results = searchSessions(sessions, "deploy");
+    expect(results[0].id).toBe("b");
+  });
+
+  test("ranks topic matches above allMessages matches", () => {
+    const sessions = [
+      makeSession({ id: "a", topic: "unrelated", allMessages: "deploy fix" }),
+      makeSession({ id: "b", topic: "deploy pipeline", allMessages: "other stuff" }),
+    ];
+    const results = searchSessions(sessions, "deploy");
+    expect(results[0].id).toBe("b");
+  });
+
+  test("ranks firstMessage matches above lastMessage", () => {
+    const sessions = [
+      makeSession({ id: "a", firstMessage: "unrelated", lastMessage: "fixed the deploy" }),
+      makeSession({ id: "b", firstMessage: "fix the deploy", lastMessage: "unrelated" }),
+    ];
+    const results = searchSessions(sessions, "deploy");
+    expect(results[0].id).toBe("b");
+  });
+
+  test("supports quoted phrase matching", () => {
+    const sessions = [
+      makeSession({ id: "a", topic: "deploy fix" }),
+      makeSession({ id: "b", topic: "fix deploy issue" }),
+    ];
+    const results = searchSessions(sessions, '"deploy fix"');
+    expect(results[0].id).toBe("a");
+  });
+
+  test("matches on project path", () => {
+    const sessions = [
+      makeSession({ id: "a", project: "createsocial", topic: "something" }),
+      makeSession({ id: "b", project: "looksmaxx", topic: "something else" }),
+    ];
+    const results = searchSessions(sessions, "createsocial");
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe("a");
+  });
+
+  test("matches on cwd", () => {
+    const sessions = [
+      makeSession({ id: "a", cwd: "/Users/tim/projects/myapp", topic: "work" }),
+      makeSession({ id: "b", cwd: "/Users/tim/other", topic: "work" }),
+    ];
+    const results = searchSessions(sessions, "myapp");
+    expect(results).toHaveLength(1);
+    expect(results[0].id).toBe("a");
+  });
+
+  test("applies recency boost for sessions within 1 day", () => {
+    const now = Date.now();
+    const sessions = [
+      makeSession({ id: "old", topic: "deploy", lastTimestamp: now - 86400000 * 30 }),
+      makeSession({ id: "recent", topic: "deploy", lastTimestamp: now - 3600000 }),
+    ];
+    const results = searchSessions(sessions, "deploy");
+    expect(results[0].id).toBe("recent");
+  });
+
+  test("handles multiple search tokens", () => {
+    const sessions = [
+      makeSession({ id: "a", topic: "fix login bug in auth" }),
+      makeSession({ id: "b", topic: "fix deploy pipeline" }),
+      makeSession({ id: "c", topic: "login page redesign" }),
+    ];
+    const results = searchSessions(sessions, "fix login");
+    expect(results[0].id).toBe("a");
+  });
+
+  test("returns results sorted by score then recency", () => {
+    const now = Date.now();
+    const sessions = [
+      makeSession({ id: "a", topic: "deploy", lastTimestamp: now - 86400000 * 10 }),
+      makeSession({ id: "b", topic: "deploy", lastTimestamp: now - 86400000 * 5 }),
+    ];
+    const results = searchSessions(sessions, "deploy");
+    expect(results[0].id).toBe("b");
+  });
+});

package/lib/format.ts

@@ -0,0 +1,177 @@
+import type { SessionEntry } from "./indexer";
+import { isGarbageSummary } from "./indexer";
+
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s;
+  // Use Array.from to split by code points, not UTF-16 code units.
+  // This prevents splitting surrogate pairs (emoji, CJK, etc.)
+  const chars = Array.from(s);
+  if (chars.length <= max) return s;
+  return chars.slice(0, max - 3).join("") + "...";
+}
+
+function formatDate(ts: number): string {
+  if (!ts) return "unknown";
+  const d = new Date(ts);
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const month = months[d.getMonth()];
+  const day = d.getDate();
+  const hours = d.getHours();
+  const mins = d.getMinutes().toString().padStart(2, "0");
+  const ampm = hours >= 12 ? "PM" : "AM";
+  const h = hours % 12 || 12;
+  return `${month} ${day}, ${h}:${mins} ${ampm}`;
+}
+
+// Get single-line display for list view — first bullet or last message
+function displayLine(s: SessionEntry): string {
+  if (s.topic && !isGarbageSummary(s.topic)) {
+    // If topic has bullets, return just the first one
+    const lines = s.topic.split("\n").filter((l: string) => l.trim().length > 0);
+    const firstBullet = lines.find((l: string) => l.startsWith("- "));
+    if (firstBullet) return firstBullet;
+    // Single-line summary (old format) — use as-is
+    return lines[0] || s.topic;
+  }
+  if (s.lastMessage) return s.lastMessage;
+  return s.firstMessage || "(no messages)";
+}
+
+// Combine name + summary for list/search views
+function makeLabel(s: SessionEntry, summary: string): string {
+  if (!s.name) return summary;
+  const clean = summary.startsWith("- ") ? summary.slice(2) : summary;
+  return `${s.name} — ${clean}`;
+}
+
+// Get full bullet summary for detail view
+function fullSummary(s: SessionEntry): string {
+  if (s.topic && !isGarbageSummary(s.topic)) return s.topic;
+  if (s.lastMessage) return s.lastMessage;
+  return s.firstMessage || "(no messages)";
+}
+
+export function formatSessionList(sessions: SessionEntry[], showAll: boolean): string {
+  const list = showAll ? sessions : sessions.slice(0, 20);
+  const lines: string[] = [];
+
+  if (!showAll && sessions.length > 20) {
+    lines.push(`${sessions.length} sessions (showing 20, use --all for all)\n`);
+  } else {
+    lines.push(`${list.length} session(s)\n`);
+  }
+
+  for (const s of list) {
+    const date = formatDate(s.lastTimestamp);
+    const msgs = `${s.messageCount} msgs`;
+    const summary = displayLine(s);
+    const label = makeLabel(s, summary);
+    const lastMsg = s.lastMessage && s.lastMessage !== summary
+      ? s.lastMessage
+      : "";
+
+    lines.push(`${s.id}    ${msgs.padStart(7)} | ${date}`);
+    lines.push(`  ${truncate(label, 100)}`);
+    if (lastMsg) {
+      lines.push(`  Left off: "${truncate(lastMsg, 90)}"`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export function formatSearchResults(sessions: SessionEntry[], query: string): string {
+  if (sessions.length === 0) {
+    return `No sessions found matching "${query}"`;
+  }
+
+  const lines: string[] = [];
+  const shown = sessions.slice(0, 15);
+  lines.push(`${sessions.length} session(s) matching "${query}"${sessions.length > 15 ? " (showing 15)" : ""}:\n`);
+
+  for (const s of shown) {
+    const date = formatDate(s.lastTimestamp);
+    const msgs = `${s.messageCount} msgs`;
+    const summary = displayLine(s);
+    const label = makeLabel(s, summary);
+    const lastMsg = s.lastMessage && s.lastMessage !== summary
+      ? s.lastMessage
+      : "";
+
+    lines.push(`${s.id}    ${msgs.padStart(7)} | ${date}`);
+    lines.push(`  ${truncate(label, 100)}`);
+    if (lastMsg) {
+      lines.push(`  Left off: "${truncate(lastMsg, 90)}"`);
+    }
+    if (s.gitBranch) {
+      lines.push(`  Branch: ${s.gitBranch}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export function formatSessionDetail(session: SessionEntry): string {
+  const s = session;
+  const lines: string[] = [];
+  lines.push(`${s.id}\n`);
+  if (s.name) {
+    lines.push(`Name:     ${s.name}`);
+  }
+  lines.push(`Project:  ${s.project}`);
+  lines.push(`CWD:      ${s.cwd}`);
+  if (s.gitBranch) {
+    lines.push(`Branch:   ${s.gitBranch}`);
+  }
+  lines.push(`Messages: ${s.messageCount}`);
+  lines.push(`Started:  ${formatDate(s.firstTimestamp)}`);
+  lines.push(`Last:     ${formatDate(s.lastTimestamp)}`);
+  lines.push("");
+  lines.push(`What was done:`);
+  lines.push(fullSummary(s));
+  lines.push("");
+  if (s.lastMessage) {
+    lines.push(`Left off: "${s.lastMessage.slice(0, 300)}"`);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+export function formatStats(sessions: SessionEntry[]): string {
+  const byProject = new Map<string, { count: number; messages: number; lastActivity: number }>();
+
+  for (const s of sessions) {
+    const key = s.project || "~";
+    const existing = byProject.get(key);
+    if (existing) {
+      existing.count++;
+      existing.messages += s.messageCount;
+      if (s.lastTimestamp > existing.lastActivity) {
+        existing.lastActivity = s.lastTimestamp;
+      }
+    } else {
+      byProject.set(key, {
+        count: 1,
+        messages: s.messageCount,
+        lastActivity: s.lastTimestamp,
+      });
+    }
+  }
+
+  const sorted = Array.from(byProject.entries()).sort((a, b) => b[1].count - a[1].count);
+
+  const lines: string[] = [];
+  lines.push(`${sessions.length} sessions across ${sorted.length} projects\n`);
+  lines.push(`  ${"Project".padEnd(30)}  ${"Sessions".padStart(8)}  ${"Messages".padStart(8)}  Last Activity`);
+  lines.push(`  ${"-".repeat(30)}  ${"-".repeat(8)}  ${"-".repeat(8)}  ${"-".repeat(18)}`);
+
+  for (const [project, data] of sorted) {
+    const p = truncate(project, 30).padEnd(30);
+    lines.push(`  ${p}  ${data.count.toString().padStart(8)}  ${data.messages.toString().padStart(8)}  ${formatDate(data.lastActivity)}`);
+  }
+
+  return lines.join("\n");
+}