@blogic-cz/agent-tools 0.6.0 → 0.7.0

package/package.json

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

package/src/session-tool/claude-code.ts

@@ -0,0 +1,272 @@
+import { Effect } from "effect";
+import { readdir } from "node:fs/promises";
+
+import type { MessageSummary } from "./types";
+
+import { SessionReadError, SessionStorageNotFoundError, type SessionError } from "./errors";
+
+export const encodeProjectPath = (dir: string): string => dir.replaceAll("/", "-");
+
+export type ContentBlock =
+  | { type: "text"; text: string }
+  | { type: "thinking"; thinking: string }
+  | { type: "tool_use"; id: string; name: string; input: unknown }
+  | { type: "tool_result"; tool_use_id: string; content: string };
+
+export type ClaudeCodeRecord =
+  | { type: "summary"; summary: string }
+  | {
+      type: "user";
+      timestamp: string;
+      uuid: string;
+      message: { role: "user"; content: string | ReadonlyArray<ContentBlock> };
+    }
+  | {
+      type: "assistant";
+      timestamp: string;
+      uuid: string;
+      message: { role: "assistant"; content: ReadonlyArray<ContentBlock> };
+    };
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+const isContentBlock = (value: unknown): value is ContentBlock => {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return false;
+  }
+
+  switch (value.type) {
+    case "text":
+      return typeof value.text === "string";
+    case "thinking":
+      return typeof value.thinking === "string";
+    case "tool_use":
+      return typeof value.id === "string" && typeof value.name === "string";
+    case "tool_result":
+      return typeof value.tool_use_id === "string" && typeof value.content === "string";
+    default:
+      return false;
+  }
+};
+
+const isUserRecord = (
+  value: Record<string, unknown>,
+): value is Extract<ClaudeCodeRecord, { type: "user" }> => {
+  if (
+    value.type !== "user" ||
+    typeof value.timestamp !== "string" ||
+    typeof value.uuid !== "string"
+  ) {
+    return false;
+  }
+
+  if (!isRecord(value.message) || value.message.role !== "user") {
+    return false;
+  }
+
+  if (typeof value.message.content === "string") {
+    return true;
+  }
+
+  return Array.isArray(value.message.content) && value.message.content.every(isContentBlock);
+};
+
+const isAssistantRecord = (
+  value: Record<string, unknown>,
+): value is Extract<ClaudeCodeRecord, { type: "assistant" }> => {
+  if (
+    value.type !== "assistant" ||
+    typeof value.timestamp !== "string" ||
+    typeof value.uuid !== "string" ||
+    !isRecord(value.message) ||
+    value.message.role !== "assistant"
+  ) {
+    return false;
+  }
+
+  return Array.isArray(value.message.content) && value.message.content.every(isContentBlock);
+};
+
+export const parseJsonlLine = (line: string): ClaudeCodeRecord | null => {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+
+  if (!isRecord(parsed) || typeof parsed.type !== "string") {
+    return null;
+  }
+
+  if (parsed.type === "summary" && typeof parsed.summary === "string") {
+    return {
+      type: "summary",
+      summary: parsed.summary,
+    };
+  }
+
+  if (isUserRecord(parsed)) {
+    return parsed;
+  }
+
+  if (isAssistantRecord(parsed)) {
+    return parsed;
+  }
+
+  if (
+    parsed.type === "system" ||
+    parsed.type === "progress" ||
+    parsed.type === "file-history-snapshot" ||
+    parsed.type === "queue-operation"
+  ) {
+    return null;
+  }
+
+  return null;
+};
+
+export const extractTextFromContent = (content: string | ReadonlyArray<ContentBlock>): string => {
+  if (typeof content === "string") {
+    return content;
+  }
+
+  return content
+    .filter((block): block is Extract<ContentBlock, { type: "text" }> => block.type === "text")
+    .map((block) => block.text)
+    .join("\n");
+};
+
+export const extractSessionTitle = (records: ReadonlyArray<ClaudeCodeRecord>): string => {
+  const summaryRecord = records.find((record) => record.type === "summary");
+  if (summaryRecord !== undefined) {
+    return summaryRecord.summary;
+  }
+
+  const firstUserRecord = records.find((record) => record.type === "user");
+  if (firstUserRecord !== undefined) {
+    return extractTextFromContent(firstUserRecord.message.content).slice(0, 100);
+  }
+
+  return "Untitled session";
+};
+
+export const getClaudeCodeSessions = (
+  basePath: string,
+  projectDir: string | null,
+): Effect.Effect<string[], SessionError> =>
+  Effect.tryPromise({
+    try: async () => {
+      const targetProjectDir = projectDir === null ? null : encodeProjectPath(projectDir);
+      const projectEntries = await readdir(basePath, { withFileTypes: true });
+
+      const sessionFiles: string[] = [];
+
+      for (const entry of projectEntries) {
+        if (!entry.isDirectory()) {
+          continue;
+        }
+
+        if (targetProjectDir !== null && entry.name !== targetProjectDir) {
+          continue;
+        }
+
+        const projectPath = `${basePath}/${entry.name}`;
+        let files: string[];
+        try {
+          // eslint-disable-next-line eslint/no-await-in-loop -- directory scan must finish before filtering file list
+          files = await readdir(projectPath);
+        } catch {
+          continue;
+        }
+
+        for (const fileName of files) {
+          if (!fileName.endsWith(".jsonl") || fileName.startsWith("agent-")) {
+            continue;
+          }
+
+          sessionFiles.push(`${projectPath}/${fileName}`);
+        }
+      }
+
+      return sessionFiles;
+    },
+    catch: (error) =>
+      new SessionStorageNotFoundError({
+        message: error instanceof Error ? error.message : "Claude Code storage directory not found",
+        path: basePath,
+      }),
+  });
+
+const getFileNameWithoutExtension = (filePath: string): string => {
+  const fileName = filePath.split("/").pop();
+  if (fileName === undefined) {
+    return "";
+  }
+
+  if (!fileName.endsWith(".jsonl")) {
+    return fileName;
+  }
+
+  return fileName.slice(0, -".jsonl".length);
+};
+
+export const readClaudeCodeMessages = (
+  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(parseJsonlLine)
+          .filter((record): record is ClaudeCodeRecord => record !== null);
+
+        const title = extractSessionTitle(records);
+        const sessionID = getFileNameWithoutExtension(sessionFile);
+
+        for (const record of records) {
+          if (record.type !== "user" && record.type !== "assistant") {
+            continue;
+          }
+
+          const createdTimestamp = new Date(record.timestamp).getTime();
+          summaries.push({
+            sessionID,
+            id: record.uuid,
+            title,
+            body: extractTextFromContent(record.message.content),
+            created: Number.isFinite(createdTimestamp) ? createdTimestamp : 0,
+            role: record.type,
+            source: "claude-code",
+          });
+        }
+      }
+
+      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 Claude Code sessions",
+        source: "claude-code",
+      }),
+  });

package/src/session-tool/config.ts

@@ -1,4 +1,5 @@
 import { Effect, Layer, ServiceMap } from "effect";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -42,6 +43,7 @@ export class ResolvedPaths extends ServiceMap.Service<
   {
     readonly messagesPath: string;
     readonly sessionsPath: string;
+    readonly claudeCodePath: string | null;
   }
 >()("@agent-tools/ResolvedPaths") {}
 
@@ -50,6 +52,8 @@ export const ResolvedPathsLayer = Layer.effect(
   Effect.gen(function* () {
     const messagesPath = yield* resolveMessagesPath;
     const sessionsPath = yield* resolveSessionsPath;
-    return { messagesPath, sessionsPath };
+    const claudeCodeBasePath = join(homedir(), ".claude/projects");
+    const claudeCodePath = existsSync(claudeCodeBasePath) ? claudeCodeBasePath : null;
+    return { messagesPath, sessionsPath, claudeCodePath };
   }),
 );

package/src/session-tool/index.ts

@@ -11,7 +11,7 @@ import { Argument, Command, Flag } from "effect/unstable/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Console, Effect, Layer, Result } from "effect";
 
-import type { MessageSummary, SessionResult } from "./types";
+import type { MessageSummary, SessionResult, SessionSource } from "./types";
 
 import { formatOption, formatOutput, VERSION } from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
@@ -21,6 +21,16 @@ 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"),
+  Flag.withDefault("all"),
+);
+
+const filterBySource = (summaries: MessageSummary[], source: string): MessageSummary[] => {
+  if (source === "all") return summaries;
+  return summaries.filter((s) => s.source === (source as SessionSource));
+};
+
 const buildScopeLabel = (searchAll: boolean, currentDir: string) => {
   if (searchAll) {
     return "all projects";
@@ -39,9 +49,14 @@ const mapSummary = (summary: MessageSummary) => {
       title: summary.title,
       body: truncate(summary.body, 500),
       created: formatDate(summary.created),
-      messagePath: `${paths.messagesPath}/${summary.sessionID}/${summary.id}.json`,
+      ...(summary.source === "opencode"
+        ? {
+            messagePath: `${paths.messagesPath}/${summary.sessionID}/${summary.id}.json`,
+            sessionPath: `${paths.messagesPath}/${summary.sessionID}`,
+          }
+        : {}),
       role: summary.role,
-      sessionPath: `${paths.messagesPath}/${summary.sessionID}`,
+      source: summary.source,
     };
   });
 };
@@ -58,8 +73,9 @@ const listCommand = Command.make(
       Flag.withDescription("Limit result count"),
       Flag.withDefault(10),
     ),
+    source: sourceOption,
   },
-  ({ all, format, limit }) =>
+  ({ all, format, limit, source }) =>
     Effect.gen(function* () {
       const sessionService = yield* SessionService;
       const startTime = Date.now();
@@ -83,11 +99,13 @@ const listCommand = Command.make(
           } satisfies SessionResult;
         }
 
-        const summaries = yield* sessionService.getMessageSummaries(sessionFilter);
+        const allSummaries = yield* sessionService.getMessageSummaries(sessionFilter);
+        const summaries = filterBySource(allSummaries, source);
         const results = summaries.slice(0, limit).map((summary) => ({
           created: formatDate(summary.created),
           sessionID: summary.sessionID,
           title: summary.title,
+          source: summary.source,
         }));
 
         return {
@@ -132,8 +150,9 @@ const searchCommand = Command.make(
       Flag.withDescription("Limit result count"),
       Flag.withDefault(10),
     ),
+    source: sourceOption,
   },
-  ({ all, format, limit, query }) =>
+  ({ all, format, limit, query, source }) =>
     Effect.gen(function* () {
       const sessionService = yield* SessionService;
       const startTime = Date.now();
@@ -158,7 +177,8 @@ const searchCommand = Command.make(
           } satisfies SessionResult;
         }
 
-        const summaries = yield* sessionService.getMessageSummaries(sessionFilter);
+        const allSummaries = yield* sessionService.getMessageSummaries(sessionFilter);
+        const summaries = filterBySource(allSummaries, source);
         const matched = sessionService.searchSummaries(summaries, query);
         const mappedResults = yield* Effect.all(matched.slice(0, limit).map(mapSummary));
 
@@ -196,15 +216,16 @@ const searchCommand = Command.make(
 
       yield* Console.log(formatOutput(output, format));
     }),
-).pipe(Command.withDescription("Search OpenCode message history"));
+).pipe(Command.withDescription("Search message history"));
 
 const readCommand = Command.make(
   "read",
   {
     session: Flag.string("session").pipe(Flag.withDescription("Session ID to read")),
     format: formatOption,
+    source: sourceOption,
   },
-  ({ format, session }) =>
+  ({ format, session, source }) =>
     Effect.gen(function* () {
       const sessionService = yield* SessionService;
       const startTime = Date.now();
@@ -226,14 +247,19 @@ const readCommand = Command.make(
             executionTimeMs: Date.now() - startTime,
           } satisfies SessionResult),
         onSuccess: (summaries) => {
-          const sessionResults = summaries.filter((summary) => summary.sessionID === session);
+          const filtered = filterBySource(summaries, source);
+          const sessionResults = filtered.filter((summary) => summary.sessionID === session);
           return Effect.all(sessionResults.map(mapSummary)).pipe(
             Effect.map(
               (mapped) =>
                 ({
                   success: true,
                   data: {
-                    files: mapped.map((message) => message.messagePath),
+                    files: mapped
+                      .map((message) =>
+                        "messagePath" in message ? (message.messagePath as string) : null,
+                      )
+                      .filter((filePath): filePath is string => filePath !== null),
                     messages: mapped,
                     session,
                   },

package/src/session-tool/service.ts

@@ -3,6 +3,7 @@ import { readdir } from "node:fs/promises";
 
 import type { MessageSummary, SessionInfo } from "./types";
 
+import { getClaudeCodeSessions, readClaudeCodeMessages } from "./claude-code";
 import { ResolvedPaths } from "./config";
 import { SessionReadError, SessionStorageNotFoundError, type SessionError } from "./errors";
 
@@ -37,6 +38,37 @@ export const truncate = (value: string, maxLen: number): string => {
 
 type FileEntry = { filePath: string; content: string };
 
+type SourceFilter = "both" | "opencode" | "claude-code";
+
+const UUID_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}$/u;
+
+const getSessionIdFromClaudeFile = (filePath: string): string => {
+  const fileName = filePath.split("/").pop() ?? "";
+  return fileName.endsWith(".jsonl") ? fileName.slice(0, -".jsonl".length) : fileName;
+};
+
+const detectSourceFilter = (filterSessions: Set<string> | null): SourceFilter => {
+  if (filterSessions === null || filterSessions.size !== 1) {
+    return "both";
+  }
+
+  const sessionId = filterSessions.values().next().value;
+  if (typeof sessionId !== "string") {
+    return "both";
+  }
+
+  if (sessionId.startsWith("ses_")) {
+    return "opencode";
+  }
+
+  if (UUID_SESSION_ID_REGEX.test(sessionId)) {
+    return "claude-code";
+  }
+
+  return "both";
+};
+
 /**
  * Reads JSON files from a two-level directory (parent/sub/*.json) using Bun.file().
  * Required for ~100k OpenCode message files where shell-per-file would timeout.
@@ -131,16 +163,42 @@ export class SessionService extends ServiceMap.Service<
         getSessionsForProject: Effect.fn("SessionService.getSessionsForProject")(function* (
           projectDir: string | null,
         ) {
-          const files = yield* readJsonFilesInTree(paths.sessionsPath);
-          const matchingSessions = new Set<string>();
+          const opencodeSessions = yield* Effect.gen(function* () {
+            const files = yield* readJsonFilesInTree(paths.sessionsPath);
+            const matchingSessions = new Set<string>();
 
-          for (const { content } of files) {
-            const parsed = parseJson<SessionInfo>(content);
-            if (parsed === null) continue;
+            for (const { content } of files) {
+              const parsed = parseJson<SessionInfo>(content);
+              if (parsed === null) continue;
 
-            if (projectDir === null || parsed.directory === projectDir) {
-              matchingSessions.add(parsed.id);
+              if (projectDir === null || parsed.directory === projectDir) {
+                matchingSessions.add(parsed.id);
+              }
             }
+
+            return matchingSessions;
+          }).pipe(
+            Effect.catchTag("SessionStorageNotFoundError", () => Effect.succeed(new Set<string>())),
+          );
+
+          const claudeSessions =
+            paths.claudeCodePath === null
+              ? new Set<string>()
+              : yield* getClaudeCodeSessions(paths.claudeCodePath, projectDir).pipe(
+                  Effect.map(
+                    (files) =>
+                      new Set<string>(
+                        files.map((filePath) => getSessionIdFromClaudeFile(filePath)),
+                      ),
+                  ),
+                  Effect.catchTag("SessionStorageNotFoundError", () =>
+                    Effect.succeed(new Set<string>()),
+                  ),
+                );
+
+          const matchingSessions = new Set<string>(opencodeSessions);
+          for (const sessionId of claudeSessions) {
+            matchingSessions.add(sessionId);
           }
 
           return matchingSessions;
@@ -149,54 +207,81 @@ export class SessionService extends ServiceMap.Service<
         getMessageSummaries: Effect.fn("SessionService.getMessageSummaries")(function* (
           filterSessions: Set<string> | null,
         ) {
-          const sessionDirs = yield* Effect.tryPromise({
-            try: async () => {
-              const dirs = await readdir(paths.messagesPath);
-              return dirs
-                .filter((name) => name.startsWith("ses_"))
-                .filter((name) => filterSessions === null || filterSessions.has(name));
-            },
-            catch: () =>
-              new SessionStorageNotFoundError({
-                message: "Message storage directory not found",
-                path: paths.messagesPath,
-              }),
-          });
+          const sourceFilter = detectSourceFilter(filterSessions);
 
-          const summaries: MessageSummary[] = [];
-
-          for (const sessionId of sessionDirs) {
-            const sessionPath = `${paths.messagesPath}/${sessionId}`;
-            const files = yield* readJsonFilesFlat(sessionPath);
-
-            for (const { filePath, content } of files) {
-              const parsed = parseJson<{
-                id?: string;
-                role?: string;
-                sessionID?: string;
-                summary?: {
-                  body?: string;
-                  title?: string;
-                };
-                time?: {
-                  created?: number;
-                };
-              }>(content);
-
-              if (parsed === null || parsed.summary?.title === undefined) {
-                continue;
-              }
+          const opencodeSummaries =
+            sourceFilter === "claude-code"
+              ? []
+              : yield* Effect.gen(function* () {
+                  const sessionDirs = yield* Effect.tryPromise({
+                    try: async () => {
+                      const dirs = await readdir(paths.messagesPath);
+                      return dirs
+                        .filter((name) => name.startsWith("ses_"))
+                        .filter((name) => filterSessions === null || filterSessions.has(name));
+                    },
+                    catch: () =>
+                      new SessionStorageNotFoundError({
+                        message: "Message storage directory not found",
+                        path: paths.messagesPath,
+                      }),
+                  });
 
-              summaries.push({
-                sessionID: parsed.sessionID ?? sessionId,
-                id: parsed.id ?? filePath.split("/").pop()?.replace(".json", "") ?? "",
-                title: parsed.summary.title,
-                body: parsed.summary.body ?? "",
-                created: parsed.time?.created ?? 0,
-                role: parsed.role ?? "unknown",
-              });
-            }
-          }
+                  const summaries: MessageSummary[] = [];
+
+                  for (const sessionId of sessionDirs) {
+                    const sessionPath = `${paths.messagesPath}/${sessionId}`;
+                    const files = yield* readJsonFilesFlat(sessionPath);
+
+                    for (const { filePath, content } of files) {
+                      const parsed = parseJson<{
+                        id?: string;
+                        role?: string;
+                        sessionID?: string;
+                        summary?: {
+                          body?: string;
+                          title?: string;
+                        };
+                        time?: {
+                          created?: number;
+                        };
+                      }>(content);
+
+                      if (parsed === null || parsed.summary?.title === undefined) {
+                        continue;
+                      }
+
+                      summaries.push({
+                        sessionID: parsed.sessionID ?? sessionId,
+                        id: parsed.id ?? filePath.split("/").pop()?.replace(".json", "") ?? "",
+                        title: parsed.summary.title,
+                        body: parsed.summary.body ?? "",
+                        created: parsed.time?.created ?? 0,
+                        role: parsed.role ?? "unknown",
+                        source: "opencode",
+                      });
+                    }
+                  }
+
+                  return summaries;
+                }).pipe(Effect.catchTag("SessionStorageNotFoundError", () => Effect.succeed([])));
+
+          const claudeSummaries =
+            sourceFilter === "opencode" || paths.claudeCodePath === null
+              ? []
+              : yield* getClaudeCodeSessions(paths.claudeCodePath, null).pipe(
+                  Effect.map((sessionFiles) =>
+                    filterSessions === null
+                      ? sessionFiles
+                      : sessionFiles.filter((sessionFile) =>
+                          filterSessions.has(getSessionIdFromClaudeFile(sessionFile)),
+                        ),
+                  ),
+                  Effect.flatMap(readClaudeCodeMessages),
+                  Effect.catchTag("SessionStorageNotFoundError", () => Effect.succeed([])),
+                );
+
+          const summaries = [...opencodeSummaries, ...claudeSummaries];
 
           return (
             summaries as MessageSummary[] & {

package/src/session-tool/types.ts

@@ -8,6 +8,8 @@ export type SessionInfo = {
   projectID: string;
 };
 
+export type SessionSource = "opencode" | "claude-code";
+
 export type MessageSummary = {
   sessionID: string;
   id: string;
@@ -15,6 +17,7 @@ export type MessageSummary = {
   body: string;
   created: number;
   role: string;
+  source: SessionSource;
 };
 
 export type SessionResult = {