claude-session-skill 1.1.6 → 1.1.8

package/lib/__tests__/search.test.ts

@@ -47,40 +47,44 @@ describe("searchSessions", () => {
     expect(results[0].id).toBe("a");
   });
 
-  test("ranks name matches highest", () => {
+  test("name match is included even without topic match", () => {
     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");
+    expect(results.map((r) => r.id)).toContain("a");
+    expect(results.map((r) => r.id)).toContain("b");
   });
 
-  test("ranks topic matches above allMessages matches", () => {
+  test("topic match is included", () => {
     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");
+    expect(results.map((r) => r.id)).toContain("a");
+    expect(results.map((r) => r.id)).toContain("b");
   });
 
-  test("ranks firstMessage matches above lastMessage", () => {
+  test("firstMessage and lastMessage matches are both included", () => {
     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");
+    expect(results.map((r) => r.id)).toContain("a");
+    expect(results.map((r) => r.id)).toContain("b");
   });
 
-  test("supports quoted phrase matching", () => {
+  test("quoted phrase filters to exact matches only", () => {
     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");
+    expect(results.map((r) => r.id)).toContain("a");
+    expect(results.map((r) => r.id)).not.toContain("b");
   });
 
   test("matches on project path", () => {
@@ -103,7 +107,7 @@ describe("searchSessions", () => {
     expect(results[0].id).toBe("a");
   });
 
-  test("applies recency boost for sessions within 1 day", () => {
+  test("results are ordered most recent first", () => {
     const now = Date.now();
     const sessions = [
       makeSession({ id: "old", topic: "deploy", lastTimestamp: now - 86400000 * 30 }),
@@ -111,19 +115,27 @@ describe("searchSessions", () => {
     ];
     const results = searchSessions(sessions, "deploy");
     expect(results[0].id).toBe("recent");
+    expect(results[1].id).toBe("old");
   });
 
-  test("handles multiple search tokens", () => {
+  test("handles multiple search tokens — all matching sessions included", () => {
+    const now = Date.now();
     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" }),
+      makeSession({ id: "a", topic: "fix login bug in auth", lastTimestamp: now - 1000 }),
+      makeSession({ id: "b", topic: "fix deploy pipeline", lastTimestamp: now - 2000 }),
+      makeSession({ id: "c", topic: "login page redesign", lastTimestamp: now - 3000 }),
     ];
     const results = searchSessions(sessions, "fix login");
+    // a and c both match ("fix login" shares tokens); b matches "fix"
+    const ids = results.map((r) => r.id);
+    expect(ids).toContain("a");
+    expect(ids).toContain("b");
+    expect(ids).toContain("c");
+    // All ordered most recent first
     expect(results[0].id).toBe("a");
   });
 
-  test("returns results sorted by score then recency", () => {
+  test("returns results sorted by most recent first regardless of score", () => {
     const now = Date.now();
     const sessions = [
       makeSession({ id: "a", topic: "deploy", lastTimestamp: now - 86400000 * 10 }),
@@ -131,5 +143,6 @@ describe("searchSessions", () => {
     ];
     const results = searchSessions(sessions, "deploy");
     expect(results[0].id).toBe("b");
+    expect(results[1].id).toBe("a");
   });
 });

package/lib/create-server.ts

@@ -0,0 +1,311 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { buildIndex, nameSession, clearSessionName, resolveSession } from "./indexer";
+import { searchSessions } from "./search";
+import {
+  formatSessionList,
+  formatSearchResults,
+  formatSessionDetail,
+  formatStats,
+  makeAutoSessionName,
+} from "./format";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+
+export function createServer(): Server {
+  const server = new Server(
+    { name: "claude-session", version: pkg.version },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "list_sessions",
+        description: "List recent Claude Code sessions with AI-generated summaries, sorted by last activity.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description: "Max sessions to return. Defaults to all sessions.",
+            },
+          },
+        },
+      },
+      {
+        name: "search_sessions",
+        description: "Search Claude Code sessions by keyword, project path, topic, or quoted phrase.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query. Supports quoted phrases for exact matches, e.g. \"auth bug\".",
+            },
+          },
+          required: ["query"],
+        },
+      },
+      {
+        name: "show_session",
+        description: "Show detailed information about a specific session: project, branch, timestamps, message count, and AI summary.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Full or partial session ID (first 8+ characters are sufficient).",
+            },
+          },
+          required: ["id"],
+        },
+      },
+      {
+        name: "name_session",
+        description: "Give a session a memorable name for easy recall. Defaults to the most recent session if no ID is provided.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Session ID or prefix. If omitted, names the most recent session.",
+            },
+            name: {
+              type: "string",
+              description: "Name to assign (max 50 characters).",
+            },
+          },
+          required: ["name"],
+        },
+      },
+      {
+        name: "autoname_session",
+        description: "Generate a session title from its summary and prefix it with the session start time as dd/mm/yy HH:MM.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Session ID or prefix. If omitted, names the most recent session.",
+            },
+          },
+        },
+      },
+      {
+        name: "unname_session",
+        description: "Remove the name from a session. Defaults to the most recent session if no ID is provided.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "Session ID or prefix. If omitted, clears the name of the most recent session.",
+            },
+          },
+          required: ["id"],
+        },
+      },
+      {
+        name: "session_stats",
+        description: "Show session statistics broken down by project: session count, message count, and last activity.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+    ],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+      switch (name) {
+        case "list_sessions": {
+          const sessions = await buildIndex();
+          const limit = typeof args?.limit === "number" ? args.limit : undefined;
+          const list = limit ? sessions.slice(0, limit) : sessions;
+          return {
+            content: [{ type: "text", text: formatSessionList(list, true) }],
+          };
+        }
+
+        case "search_sessions": {
+          const query = String(args?.query ?? "").trim();
+          if (!query) {
+            return {
+              content: [{ type: "text", text: "Error: query is required." }],
+              isError: true,
+            };
+          }
+          const sessions = await buildIndex();
+          const results = searchSessions(sessions, query);
+          return {
+            content: [{ type: "text", text: formatSearchResults(results, query) }],
+          };
+        }
+
+        case "show_session": {
+          const id = String(args?.id ?? "").trim();
+          if (!id) {
+            return {
+              content: [{ type: "text", text: "Error: id is required." }],
+              isError: true,
+            };
+          }
+          const sessions = await buildIndex();
+          const resolved = resolveSession(sessions, id);
+          if (!resolved.ok) {
+            return {
+              content: [{ type: "text", text: `Error: ${resolved.error}` }],
+              isError: true,
+            };
+          }
+          return {
+            content: [{ type: "text", text: formatSessionDetail(resolved.match) }],
+          };
+        }
+
+        case "name_session": {
+          const sessionName = String(args?.name ?? "").trim();
+          if (!sessionName) {
+            return {
+              content: [{ type: "text", text: "Error: name is required." }],
+              isError: true,
+            };
+          }
+
+          let sessionId: string;
+          if (args?.id) {
+            sessionId = String(args.id).trim();
+          } else {
+            // Default to most recent session
+            const sessions = await buildIndex();
+            if (sessions.length === 0) {
+              return {
+                content: [{ type: "text", text: "Error: No sessions found." }],
+                isError: true,
+              };
+            }
+            sessionId = sessions[0].id;
+          }
+
+          const result = await nameSession(sessionId, sessionName);
+          if (!result.ok) {
+            return {
+              content: [{ type: "text", text: `Error: ${result.error}` }],
+              isError: true,
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Named session ${(result.fullId ?? "").slice(0, 8)}... → "${sessionName}"`,
+              },
+            ],
+          };
+        }
+
+        case "autoname_session": {
+          const sessions = await buildIndex();
+          if (sessions.length === 0) {
+            return {
+              content: [{ type: "text", text: "Error: No sessions found." }],
+              isError: true,
+            };
+          }
+
+          const sessionId = args?.id ? String(args.id).trim() : sessions[0].id;
+          const resolved = resolveSession(sessions, sessionId);
+          if (!resolved.ok) {
+            return {
+              content: [{ type: "text", text: `Error: ${resolved.error}` }],
+              isError: true,
+            };
+          }
+
+          const generatedName = makeAutoSessionName(resolved.match);
+          const result = await nameSession(resolved.match.id, generatedName);
+          if (!result.ok) {
+            return {
+              content: [{ type: "text", text: `Error: ${result.error}` }],
+              isError: true,
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Named session ${(result.fullId ?? "").slice(0, 8)}... → "${generatedName}"`,
+              },
+            ],
+          };
+        }
+
+        case "unname_session": {
+          let sessionId: string;
+          if (args?.id) {
+            sessionId = String(args.id).trim();
+          } else {
+            const sessions = await buildIndex();
+            if (sessions.length === 0) {
+              return {
+                content: [{ type: "text", text: "Error: No sessions found." }],
+                isError: true,
+              };
+            }
+            sessionId = sessions[0].id;
+          }
+
+          const result = await clearSessionName(sessionId);
+          if (!result.ok) {
+            return {
+              content: [{ type: "text", text: `Error: ${result.error}` }],
+              isError: true,
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Cleared name from session ${(result.fullId ?? "").slice(0, 8)}...`,
+              },
+            ],
+          };
+        }
+
+        case "session_stats": {
+          const sessions = await buildIndex();
+          return {
+            content: [{ type: "text", text: formatStats(sessions) }],
+          };
+        }
+
+        default:
+          return {
+            content: [{ type: "text", text: `Error: Unknown tool "${name}"` }],
+            isError: true,
+          };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+      };
+    }
+  });
+
+  return server;
+}

package/lib/format.ts

@@ -10,6 +10,10 @@ function truncate(s: string, max: number): string {
   return chars.slice(0, max - 3).join("") + "...";
 }
 
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
 function formatDate(ts: number): string {
   if (!ts) return "unknown";
   const d = new Date(ts);
@@ -23,8 +27,19 @@ function formatDate(ts: number): string {
   return `${month} ${day}, ${h}:${mins} ${ampm}`;
 }
 
+function formatNameTimestamp(ts: number): string {
+  if (!ts) return "unknown";
+  const d = new Date(ts);
+  const day = d.getDate().toString().padStart(2, "0");
+  const month = (d.getMonth() + 1).toString().padStart(2, "0");
+  const year = (d.getFullYear() % 100).toString().padStart(2, "0");
+  const hours = d.getHours().toString().padStart(2, "0");
+  const minutes = d.getMinutes().toString().padStart(2, "0");
+  return `${day}/${month}/${year} ${hours}:${minutes}`;
+}
+
 // Get single-line display for list view — first bullet or last message
-function displayLine(s: SessionEntry): string {
+export 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);
@@ -37,6 +52,21 @@ function displayLine(s: SessionEntry): string {
   return s.firstMessage || "(no messages)";
 }
 
+export function makeAutoSessionName(s: SessionEntry, maxLength = 50): string {
+  const prefix = formatNameTimestamp(s.firstTimestamp);
+  const summary = displayLine(s);
+  const cleanSummary = normalizeWhitespace(
+    summary.startsWith("- ") ? summary.slice(2) : summary
+  ).replace(/^["']+|["']+$/g, "");
+
+  if (!cleanSummary) return prefix;
+
+  const available = maxLength - prefix.length - 1;
+  if (available <= 0) return prefix.slice(0, maxLength);
+
+  return `${prefix} ${truncate(cleanSummary, available)}`;
+}
+
 // Combine name + summary for list/search views
 function makeLabel(s: SessionEntry, summary: string): string {
   if (!s.name) return summary;

package/lib/search.ts

@@ -74,8 +74,8 @@ export function searchSessions(
     scored.push({ session, score });
   }
 
-  // Sort by score desc, then by lastTimestamp desc
-  scored.sort((a, b) => b.score - a.score || b.session.lastTimestamp - a.session.lastTimestamp);
+  // Sort by most recent first (timestamp desc). Score only determines inclusion, not order.
+  scored.sort((a, b) => b.session.lastTimestamp - a.session.lastTimestamp);
 
   return scored.map((s) => s.session);
 }