@code-fixer-23/pi-session-manager 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+## 1.0.5 (2026-07-08)
+
+### 🩹 Fixes
+
+- prompt parsing and session-series continuation ([#6](https://github.com/louiss0/pi-packages/pull/6))
+
+### ❤️ Thank You
+
+- louiss0 @louiss0
+
+## 1.0.4 (2026-07-04)
+
+### 🩹 Fixes
+
+- **pi-session-manager:** do proper session restoration ([271d67d](https://github.com/louiss0/pi-packages/commit/271d67d))
+
+### ❤️ Thank You
+
+- louiss0 @louiss0
+
 ## 1.0.3 (2026-07-03)
 
 ### 🩹 Fixes

package/extensions/index.test.ts

@@ -11,6 +11,7 @@ import {
   handleSessionCleanOlderThan,
   handleSessionDeleteLast,
   handleSessionSeries,
+  getSessionEntryWithSeries,
   getSessionSeriesDataTempPath,
   persistSessionSeriesData,
   consumePersistedSessionSeriesData,
@@ -254,6 +255,7 @@ describe("persisted session series data", () => {
       entry: {
         customType: sessionSeriesEntrySchema.entries.customType.literal,
         series: "Implement Auth",
+        sessionTitle: "Create JWT Token",
         createdAt: new Date().toISOString(),
       },
     };
@@ -279,6 +281,7 @@ describe("persisted session series data", () => {
     expect(pi.setSessionName).toHaveBeenCalledWith(sessionData.sessionName);
     expect(pi.appendEntry).toHaveBeenCalledWith(sessionData.entry.customType, {
       series: sessionData.entry.series,
+      sessionTitle: sessionData.entry.sessionTitle,
       createdAt: sessionData.entry.createdAt,
     });
     expect(ctx.ui.notify).toHaveBeenCalledWith(
@@ -288,6 +291,82 @@ describe("persisted session series data", () => {
   });
 });
 
+describe("getSessionEntryWithSeries", () => {
+  it("only returns the series entry that matches the current session name", () => {
+    const createdAt = new Date().toISOString();
+    const lspCoverageEntry = {
+      type: "custom",
+      customType: sessionSeriesEntrySchema.entries.customType.literal,
+      data: {
+        series: "LSP Coverage",
+        sessionTitle: "Add diagnostics",
+        createdAt,
+      },
+    } as SessionSeriesEntry;
+    const authEntry = {
+      type: "custom",
+      customType: sessionSeriesEntrySchema.entries.customType.literal,
+      data: {
+        series: "Auth Cleanup",
+        sessionTitle: "Fix token refresh",
+        createdAt,
+      },
+    } as SessionSeriesEntry;
+
+    expect(
+      getSessionEntryWithSeries(
+        [lspCoverageEntry, authEntry],
+        `Auth Cleanup${SESION_TITLE_SEPARATOR}Fix token refresh`,
+      ),
+    ).toBe(authEntry);
+  });
+
+  it("does not return another session's series entry", () => {
+    const createdAt = new Date().toISOString();
+    const lspCoverageEntry = {
+      type: "custom",
+      customType: sessionSeriesEntrySchema.entries.customType.literal,
+      data: {
+        series: "LSP Coverage",
+        sessionTitle: "Add diagnostics",
+        createdAt,
+      },
+    } as SessionSeriesEntry;
+
+    expect(
+      getSessionEntryWithSeries(
+        [lspCoverageEntry],
+        `Auth Cleanup${SESION_TITLE_SEPARATOR}Fix token refresh`,
+      ),
+    ).toBeUndefined();
+  });
+
+  it("falls back to the session name when legacy series entries are missing sessionTitle", () => {
+    const createdAt = new Date().toISOString();
+    const legacyEntry = {
+      type: "custom",
+      customType: sessionSeriesEntrySchema.entries.customType.literal,
+      data: {
+        series: "Auth Cleanup",
+        createdAt,
+      },
+    } as unknown as SessionSeriesEntry;
+
+    expect(
+      getSessionEntryWithSeries(
+        [legacyEntry],
+        `Auth Cleanup${SESION_TITLE_SEPARATOR}Fix token refresh`,
+      ),
+    ).toEqual({
+      ...legacyEntry,
+      data: {
+        ...legacyEntry.data,
+        sessionTitle: "Fix token refresh",
+      },
+    });
+  });
+});
+
 describe("handleSessionCleanInactive", () => {
   test("gets rid of all sessions that haven't been modified in the last three days", ({
     sessions,
@@ -507,6 +586,40 @@ describe("handleSessionSeries", () => {
       );
     });
 
+    it("stops creating a session series when the series prompt is cancelled", async () => {
+      const context = {
+        cwd: "/pi-packages",
+        newSession: vi.fn<ExtensionCommandContext["newSession"]>(),
+        ui: {
+          notify: vi.fn<ExtensionUIContext["notify"]>(),
+          input: vi
+            .fn<ExtensionUIContext["input"]>()
+            .mockResolvedValue(undefined),
+        },
+      } satisfies MockExtenstionCommandContext;
+
+      await handleSessionSeries(
+        "create",
+        {
+          sessionManagerConfigurator: new SessionManagerConfiguratorMock(),
+          sessionFilter: new MockSessionFilter(
+            [],
+            new MockPastTimestampCalculator(),
+          ),
+          getSessionEntryWithSeries() {
+            return undefined;
+          },
+          removeSessionFiles() {
+            return;
+          },
+        },
+        castToExtensionContext(context),
+      );
+
+      expect(context.ui.input).toHaveBeenCalledTimes(1);
+      expect(context.newSession).not.toHaveBeenCalled();
+    });
+
     const seriesInput = "Implement Auth";
     it("keeps asking for a unique trimmed session series when creating", async () => {
       const sessionCtx = {
@@ -834,6 +947,50 @@ describe("handleSessionSeries", () => {
     );
   });
 
+  it("stops creating a new session in a series when the title prompt is cancelled", async () => {
+    const selectedSeries = "refactor-auth-middleware";
+    const context = {
+      cwd: "/user/work/cancel-new-title",
+      newSession: vi.fn<ExtensionCommandContext["newSession"]>(),
+      ui: {
+        notify: vi.fn<ExtensionUIContext["notify"]>(),
+        input: vi
+          .fn<ExtensionUIContext["input"]>()
+          .mockResolvedValue(undefined),
+        select: vi
+          .fn<ExtensionUIContext["select"]>()
+          .mockResolvedValue(selectedSeries),
+      },
+    } satisfies MockExtenstionCommandContext;
+
+    await handleSessionSeries(
+      "new",
+      {
+        sessionManagerConfigurator: new SessionManagerConfiguratorMock({
+          seriesRecord: {
+            [context.cwd]: {
+              [selectedSeries]: [],
+            },
+          },
+        }),
+        sessionFilter: new MockSessionFilter(
+          [],
+          new MockPastTimestampCalculator(),
+        ),
+        getSessionEntryWithSeries() {
+          return undefined;
+        },
+        removeSessionFiles() {
+          return;
+        },
+      },
+      castToExtensionContext(context),
+    );
+
+    expect(context.ui.input).toHaveBeenCalledTimes(1);
+    expect(context.newSession).not.toHaveBeenCalled();
+  });
+
   it("keeps asking for a unique trimmed title when creating a new session in a series", async () => {
     const selectedSeries = "refactor-auth-middleware";
 
@@ -922,6 +1079,55 @@ describe("handleSessionSeries", () => {
     );
   });
 
+  it("stops continuing a session in a series when the title prompt is cancelled", async () => {
+    const context = {
+      cwd: "/user/work/cancel-continue-title",
+      sessionManager: {
+        getEntries:
+          vi.fn<ExtensionCommandContext["sessionManager"]["getEntries"]>(),
+        getSessionName: vi
+          .fn<ExtensionCommandContext["sessionManager"]["getSessionName"]>()
+          .mockReturnValue("refactor-auth-middleware--current-task"),
+      },
+      newSession: vi.fn<ExtensionCommandContext["newSession"]>(),
+      ui: {
+        notify: vi.fn<ExtensionUIContext["notify"]>(),
+        input: vi
+          .fn<ExtensionUIContext["input"]>()
+          .mockResolvedValue(undefined),
+      },
+    } satisfies MockExtenstionCommandContext;
+
+    await handleSessionSeries(
+      "continue",
+      {
+        sessionFilter: new MockSessionFilter(
+          [],
+          new MockPastTimestampCalculator(),
+        ),
+        getSessionEntryWithSeries() {
+          return {
+            type: "custom",
+            customType: sessionSeriesEntrySchema.entries.customType.literal,
+            data: {
+              series: "refactor-auth-middleware",
+              sessionTitle: "current-task",
+              createdAt: new Date().toISOString(),
+            },
+          } as SessionSeriesEntry;
+        },
+        sessionManagerConfigurator: new SessionManagerConfiguratorMock(),
+        removeSessionFiles() {
+          return;
+        },
+      },
+      castToExtensionContext(context),
+    );
+
+    expect(context.ui.input).toHaveBeenCalledTimes(1);
+    expect(context.newSession).not.toHaveBeenCalled();
+  });
+
   it("continues a session in a series when continue is passed", async () => {
     const sessionCtx = {
       cwd: "/session/continue",
@@ -935,6 +1141,9 @@ describe("handleSessionSeries", () => {
       sessionManager: {
         getEntries:
           vi.fn<ExtensionCommandContext["sessionManager"]["getEntries"]>(),
+        getSessionName: vi
+          .fn<ExtensionCommandContext["sessionManager"]["getSessionName"]>()
+          .mockReturnValue("refactor-auth-middleware--current-task"),
       },
       newSession: vi.fn<ExtensionCommandContext["newSession"]>(
         async (options) => {
@@ -957,6 +1166,7 @@ describe("handleSessionSeries", () => {
       customType: sessionSeriesEntrySchema.entries.customType.literal,
       data: {
         series: "refactor-auth-middleware",
+        sessionTitle: "current-task",
         createdAt: new Date().toISOString(),
       },
     } as SessionSeriesEntry;
@@ -1010,6 +1220,7 @@ describe("handleSessionSeries", () => {
 
     expect(getSessionEntryWithSeries).toHaveBeenCalledWith(
       context.sessionManager.getEntries.mock.results[0]?.value,
+      context.sessionManager.getSessionName(),
     );
 
     const entry = getSessionEntryWithSeries.mock.results[0]

package/extensions/index.ts

@@ -45,14 +45,17 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_start", async (event, ctx) => {
     sessionManagerConfigurator = new SessionManagerConfigurator();
+
+    if (event.reason !== "fork" && event.reason !== "reload") {
+      applyPersistedSessionSeriesData(pi, ctx);
+    }
+
     const eventIsNotReloadOrStartUp =
       event.reason !== "reload" && event.reason !== "startup";
     if (eventIsNotReloadOrStartUp) {
       return;
     }
 
-    applyPersistedSessionSeriesData(pi, ctx);
-
     const dayLimitResult =
       sessionManagerConfigurator.getSessionDeletionDayLimit();
 
@@ -512,14 +515,56 @@ class SessionManagerConfigurator implements $SessionManagerConfigurator {
   }
 }
 
-function getSessionEntryWithSeries(
-  sesssionEntries: SessionEntry[],
+export function getSessionEntryWithSeries(
+  sessionEntries: SessionEntry[],
+  sessionName?: string,
 ): SessionSeriesEntry | undefined {
-  return sesssionEntries.find(
+  const matchingEntries = sessionEntries.filter(
     (entry): entry is SessionSeriesEntry =>
       entry.type === sessionSeriesEntrySchema.entries.type.literal &&
       entry.customType === sessionSeriesEntrySchema.entries.customType.literal,
   );
+
+  if (!sessionName) {
+    return;
+  }
+
+  const normalizedSessionName = sessionName.trim();
+  const matchedEntry = matchingEntries.find((entry) => {
+    const sessionTitle =
+      entry.data.sessionTitle ??
+      getSessionTitleFromSessionName(normalizedSessionName, entry.data.series);
+
+    if (!sessionTitle) {
+      return false;
+    }
+
+    return (
+      `${entry.data.series}${SESION_TITLE_SEPARATOR}${sessionTitle}` ===
+      normalizedSessionName
+    );
+  });
+
+  if (!matchedEntry || matchedEntry.data.sessionTitle) {
+    return matchedEntry;
+  }
+
+  const sessionTitle = getSessionTitleFromSessionName(
+    normalizedSessionName,
+    matchedEntry.data.series,
+  );
+
+  if (!sessionTitle) {
+    return matchedEntry;
+  }
+
+  return {
+    ...matchedEntry,
+    data: {
+      ...matchedEntry.data,
+      sessionTitle,
+    },
+  } as SessionSeriesEntry;
 }
 
 export type GetSessionEntryWithSeries = typeof getSessionEntryWithSeries;
@@ -617,6 +662,17 @@ export function handleSessionDeleteLast(
 }
 
 export const SESION_TITLE_SEPARATOR = "--";
+
+function getSessionTitleFromSessionName(sessionName: string, series: string) {
+  const prefix = `${series.trim()}${SESION_TITLE_SEPARATOR}`;
+
+  if (!sessionName.startsWith(prefix)) {
+    return;
+  }
+
+  return sessionName.slice(prefix.length).trim();
+}
+
 export const sessionSeriesCommandsSchema = picklist([
   "create",
   "delete",
@@ -628,6 +684,7 @@ export const sessionSeriesEntrySchema = object({
   customType: literal("session-manager/series"),
   data: object({
     series: string(),
+    sessionTitle: string(),
     createdAt: pipe(string(), isoTimestamp()),
   }),
 });
@@ -640,6 +697,7 @@ export const sessionSeriesDataSchema = object({
   entry: object({
     customType: literal("session-manager/series"),
     series: string(),
+    sessionTitle: string(),
     createdAt: pipe(string(), isoTimestamp()),
   }),
 });
@@ -718,6 +776,10 @@ function promptForUniqueTrimmedInput(
       const value = await ctx.ui.input(prompt, description);
       const trimmedValue = value?.trim();
 
+      if (value === undefined) {
+        return;
+      }
+
       if (!trimmedValue) {
         continue;
       }
@@ -777,6 +839,10 @@ export async function handleSessionSeries(
         (value) => `This series has already been added ${value}`,
       );
 
+      if (!series) {
+        return;
+      }
+
       const titlesResult =
         deps.sessionManagerConfigurator.getSessionTitlesForSeriesBasedOnCwd(
           ctx.cwd,
@@ -796,11 +862,17 @@ export async function handleSessionSeries(
         (value) => `This title has already been added ${value}`,
       );
 
+      if (!title) {
+        return;
+      }
+
+      const sessionName = `${series}${SESION_TITLE_SEPARATOR}${title}`;
       const sessionData = {
-        sessionName: `${series}${SESION_TITLE_SEPARATOR}${title}`,
+        sessionName,
         entry: {
           customType: sessionSeriesEntrySchema.entries.customType.literal,
           series,
+          sessionTitle: title,
           createdAt: new Date().toISOString(),
         },
       };
@@ -890,11 +962,17 @@ export async function handleSessionSeries(
         (value) => `This title has already been added ${value}`,
       );
 
+      if (!title) {
+        return;
+      }
+
+      const sessionName = `${series}${SESION_TITLE_SEPARATOR}${title}`;
       const sessionData = {
-        sessionName: `${series}${SESION_TITLE_SEPARATOR}${title}`,
+        sessionName,
         entry: {
           customType: sessionSeriesEntrySchema.entries.customType.literal,
           series,
+          sessionTitle: title,
           createdAt: new Date().toISOString(),
         },
       };
@@ -920,7 +998,10 @@ export async function handleSessionSeries(
 
     case "continue": {
       const entries = ctx.sessionManager.getEntries();
-      const entry = deps.getSessionEntryWithSeries(entries);
+      const entry = deps.getSessionEntryWithSeries(
+        entries,
+        ctx.sessionManager.getSessionName(),
+      );
 
       if (!entry) {
         ctx.ui.notify("No session series was found", "error");
@@ -942,11 +1023,17 @@ export async function handleSessionSeries(
         (value) => `This title has already been added ${value}`,
       );
 
+      if (!title) {
+        return;
+      }
+
+      const sessionName = `${entry.data.series}${SESION_TITLE_SEPARATOR}${title}`;
       const sessionData = {
-        sessionName: `${entry.data.series}${SESION_TITLE_SEPARATOR}${title}`,
+        sessionName,
         entry: {
           customType: sessionSeriesEntrySchema.entries.customType.literal,
           series: entry.data.series,
+          sessionTitle: title,
           createdAt: new Date().toISOString(),
         },
       };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@code-fixer-23/pi-session-manager",
   "type": "module",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "keywords": [
     "pi-package"
   ],