@blogic-cz/agent-tools 0.14.56 → 0.14.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.14.56",
+  "version": "0.14.58",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",

package/src/gh-tool/pr/review.ts

@@ -368,6 +368,7 @@ const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]):
         isVisibleOpen: !node.isResolved || needsHumanReply,
         lastReplyAuthor: lastReply?.author ?? null,
         lastReplyAt: lastReply?.createdAt ?? null,
+        duplicateThreadIds: [] as string[],
       };
     })
     .filter((thread): thread is ReviewThread => thread !== null);
@@ -383,8 +384,14 @@ const enrichThreads = (threads: ThreadNode[], reviewComments: ReviewComment[]):
       continue;
     }
     const existing = deduped[existingIndex];
-    if (existing !== undefined && existing.isResolved && !thread.isResolved) {
+    if (existing === undefined) {
+      continue;
+    }
+    if (existing.isResolved && !thread.isResolved) {
+      thread.duplicateThreadIds = [existing.threadId, ...existing.duplicateThreadIds];
       deduped[existingIndex] = thread;
+    } else {
+      existing.duplicateThreadIds.push(thread.threadId);
     }
   }
 

package/src/gh-tool/types.ts

@@ -37,6 +37,8 @@ export type ReviewThread = {
   isVisibleOpen: boolean;
   lastReplyAuthor: string | null;
   lastReplyAt: string | null;
+  /** Thread ids of exact duplicates collapsed into this representative (encounter order). */
+  duplicateThreadIds: string[];
 };
 
 export type ReviewComment = {

package/src/session-tool/config.ts

@@ -45,6 +45,7 @@ export class ResolvedPaths extends Context.Service<
     readonly sessionsPath: string;
     readonly claudeCodePath: string | null;
     readonly codexPath: string | null;
+    readonly piPath: string | null;
   }
 >()("@agent-tools/ResolvedPaths") {}
 
@@ -57,6 +58,8 @@ export const ResolvedPathsLayer = Layer.effect(
     const claudeCodePath = existsSync(claudeCodeBasePath) ? claudeCodeBasePath : null;
     const codexBasePath = join(homedir(), ".codex/sessions");
     const codexPath = existsSync(codexBasePath) ? codexBasePath : null;
-    return { messagesPath, sessionsPath, claudeCodePath, codexPath };
+    const piBasePath = join(homedir(), ".pi/agent/sessions");
+    const piPath = existsSync(piBasePath) ? piBasePath : null;
+    return { messagesPath, sessionsPath, claudeCodePath, codexPath, piPath };
   }),
 );

package/src/session-tool/index.ts

@@ -22,7 +22,7 @@ import { formatDate, SessionService, SessionServiceLayer, truncate } from "./ser
 const AppLayer = SessionServiceLayer.pipe(Layer.provideMerge(ResolvedPathsLayer));
 
 const sourceOption = Flag.string("source").pipe(
-  Flag.withDescription("Filter by source: all, opencode, claude-code, codex"),
+  Flag.withDescription("Filter by source: all, opencode, claude-code, codex, pi"),
   Flag.withDefault("all"),
 );
 

package/src/session-tool/pi.ts

@@ -0,0 +1,191 @@
+import { Effect } from "effect";
+
+import type { MessageSummary } from "./types";
+
+import { SessionReadError, SessionStorageNotFoundError, type SessionError } from "./errors";
+
+export type PiContentBlock =
+  | { type: "text"; text: string }
+  | { type: string; [key: string]: unknown };
+
+export type PiRecord =
+  | { type: "session"; id: string; timestamp?: string; cwd?: string }
+  | {
+      type: "message";
+      timestamp: string;
+      message: { role: string; content: string | ReadonlyArray<PiContentBlock> };
+    };
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+export const parsePiLine = (line: string): PiRecord | null => {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+
+  if (!isRecord(parsed) || typeof parsed.type !== "string") {
+    return null;
+  }
+
+  if (parsed.type === "session" && typeof parsed.id === "string") {
+    return {
+      type: "session",
+      id: parsed.id,
+      timestamp: typeof parsed.timestamp === "string" ? parsed.timestamp : undefined,
+      cwd: typeof parsed.cwd === "string" ? parsed.cwd : undefined,
+    };
+  }
+
+  if (
+    parsed.type === "message" &&
+    typeof parsed.timestamp === "string" &&
+    isRecord(parsed.message) &&
+    typeof parsed.message.role === "string" &&
+    (typeof parsed.message.content === "string" || Array.isArray(parsed.message.content))
+  ) {
+    return parsed as Extract<PiRecord, { type: "message" }>;
+  }
+
+  return null;
+};
+
+export const extractPiText = (content: string | ReadonlyArray<PiContentBlock>): string => {
+  if (typeof content === "string") {
+    return content;
+  }
+
+  return content
+    .filter(
+      (block): block is { type: "text"; text: string } =>
+        block.type === "text" && typeof (block as { text?: unknown }).text === "string",
+    )
+    .map((block) => block.text)
+    .join("\n");
+};
+
+export const extractPiTitle = (records: ReadonlyArray<PiRecord>): string => {
+  const firstUser = records.find(
+    (record): record is Extract<PiRecord, { type: "message" }> =>
+      record.type === "message" && record.message.role === "user",
+  );
+  if (firstUser !== undefined) {
+    return extractPiText(firstUser.message.content).slice(0, 100);
+  }
+
+  return "Untitled session";
+};
+
+const SESSION_ID_REGEX =
+  /_([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/u;
+
+export const getPiSessionId = (filePath: string): string => {
+  const fileName = filePath.split("/").pop() ?? "";
+  const match = SESSION_ID_REGEX.exec(fileName);
+  return match?.[1] ?? fileName.replace(/\.jsonl$/u, "");
+};
+
+const walkSessionFiles = async (basePath: string): Promise<string[]> => {
+  const { Glob } = await import("bun");
+  const glob = new Glob("*/*.jsonl");
+  return Array.fromAsync(glob.scan({ cwd: basePath, absolute: true }));
+};
+
+const readSessionCwd = async (sessionFile: string): Promise<string | null> => {
+  try {
+    const text = await Bun.file(sessionFile).text();
+    const firstLine = text.split("\n")[0] ?? "";
+    const record = parsePiLine(firstLine);
+    if (record !== null && record.type === "session") {
+      return record.cwd ?? null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+
+export const getPiSessions = (
+  basePath: string,
+  projectDir: string | null,
+): Effect.Effect<string[], SessionError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const allFiles = await walkSessionFiles(basePath);
+      if (projectDir === null) {
+        return allFiles;
+      }
+
+      const cwds = await Promise.all(allFiles.map((file) => readSessionCwd(file)));
+      return allFiles.filter((_, i) => cwds[i] === projectDir);
+    },
+    catch: (error) =>
+      new SessionStorageNotFoundError({
+        message: error instanceof Error ? error.message : "pi storage directory not found",
+        path: basePath,
+      }),
+  });
+
+export const readPiMessages = (
+  sessionFiles: string[],
+): Effect.Effect<MessageSummary[], SessionError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const summaries: MessageSummary[] = [];
+
+      for (const sessionFile of sessionFiles) {
+        let fileContent: string;
+        try {
+          // eslint-disable-next-line eslint/no-await-in-loop -- sequential file read keeps memory bounded
+          fileContent = await Bun.file(sessionFile).text();
+        } catch {
+          continue;
+        }
+
+        const records = fileContent
+          .split(/\r?\n/u)
+          .map((line) => line.trim())
+          .filter((line) => line.length > 0)
+          .map(parsePiLine)
+          .filter((record): record is PiRecord => record !== null);
+
+        const title = extractPiTitle(records);
+        const sessionID = getPiSessionId(sessionFile);
+
+        for (const record of records) {
+          if (record.type !== "message") continue;
+          if (record.message.role !== "user" && record.message.role !== "assistant") continue;
+
+          const body = extractPiText(record.message.content);
+          if (body.length === 0) continue;
+
+          const createdTimestamp = new Date(record.timestamp).getTime();
+          summaries.push({
+            sessionID,
+            id: `${sessionID}:${record.timestamp}`,
+            title,
+            body,
+            created: Number.isFinite(createdTimestamp) ? createdTimestamp : 0,
+            role: record.message.role,
+            source: "pi",
+          });
+        }
+      }
+
+      return (
+        summaries as MessageSummary[] & {
+          toSorted(
+            compareFn: (left: MessageSummary, right: MessageSummary) => number,
+          ): MessageSummary[];
+        }
+      ).toSorted((left, right) => right.created - left.created);
+    },
+    catch: (error) =>
+      new SessionReadError({
+        message: error instanceof Error ? error.message : "Failed to read pi sessions",
+        source: "pi",
+      }),
+  });

package/src/session-tool/service.ts

@@ -5,6 +5,7 @@ import type { MessageSummary, SessionInfo, SessionSource } from "./types";
 
 import { getClaudeCodeSessions, readClaudeCodeMessages } from "./claude-code";
 import { getCodexSessions, getCodexSessionId, readCodexMessages } from "./codex";
+import { getPiSessions, getPiSessionId, readPiMessages } from "./pi";
 import { ResolvedPaths } from "./config";
 import { SessionReadError, SessionStorageNotFoundError, type SessionError } from "./errors";
 
@@ -41,8 +42,13 @@ type FileEntry = { filePath: string; content: string };
 
 type SourceFilter = ReadonlySet<SessionSource>;
 
-const ALL_SOURCES: SourceFilter = new Set<SessionSource>(["opencode", "claude-code", "codex"]);
-const UUID_SOURCES: SourceFilter = new Set<SessionSource>(["claude-code", "codex"]);
+const ALL_SOURCES: SourceFilter = new Set<SessionSource>([
+  "opencode",
+  "claude-code",
+  "codex",
+  "pi",
+]);
+const UUID_SOURCES: SourceFilter = new Set<SessionSource>(["claude-code", "codex", "pi"]);
 const OPENCODE_ONLY: SourceFilter = new Set<SessionSource>(["opencode"]);
 
 const UUID_SESSION_ID_REGEX =
@@ -214,6 +220,18 @@ export class SessionService extends Context.Service<
                   ),
                 );
 
+          const piSessions =
+            paths.piPath === null
+              ? new Set<string>()
+              : yield* getPiSessions(paths.piPath, projectDir).pipe(
+                  Effect.map(
+                    (files) => new Set<string>(files.map((filePath) => getPiSessionId(filePath))),
+                  ),
+                  Effect.catchTag("SessionStorageNotFoundError", () =>
+                    Effect.succeed(new Set<string>()),
+                  ),
+                );
+
           const matchingSessions = new Set<string>(opencodeSessions);
           for (const sessionId of claudeSessions) {
             matchingSessions.add(sessionId);
@@ -221,6 +239,9 @@ export class SessionService extends Context.Service<
           for (const sessionId of codexSessions) {
             matchingSessions.add(sessionId);
           }
+          for (const sessionId of piSessions) {
+            matchingSessions.add(sessionId);
+          }
 
           return matchingSessions;
         }),
@@ -319,7 +340,30 @@ export class SessionService extends Context.Service<
                   }),
                 );
 
-          const summaries = [...opencodeSummaries, ...claudeSummaries, ...codexSummaries];
+          const piSummaries =
+            !sourceFilter.has("pi") || paths.piPath === null
+              ? []
+              : yield* getPiSessions(paths.piPath, null).pipe(
+                  Effect.map((sessionFiles) =>
+                    filterSessions === null
+                      ? sessionFiles
+                      : sessionFiles.filter((sessionFile) =>
+                          filterSessions.has(getPiSessionId(sessionFile)),
+                        ),
+                  ),
+                  Effect.flatMap(readPiMessages),
+                  Effect.catchTags({
+                    SessionStorageNotFoundError: () => Effect.succeed([]),
+                    SessionReadError: () => Effect.succeed([]),
+                  }),
+                );
+
+          const summaries = [
+            ...opencodeSummaries,
+            ...claudeSummaries,
+            ...codexSummaries,
+            ...piSummaries,
+          ];
 
           return (
             summaries as MessageSummary[] & {

package/src/session-tool/types.ts

@@ -10,7 +10,7 @@ export type SessionInfo = {
   projectID: string;
 };
 
-export const SessionSourceLiterals = Schema.Literals(["opencode", "claude-code", "codex"]);
+export const SessionSourceLiterals = Schema.Literals(["opencode", "claude-code", "codex", "pi"]);
 export type SessionSource = Schema.Schema.Type<typeof SessionSourceLiterals>;
 
 export type MessageSummary = {