@kimuson/claude-code-viewer 0.4.2 → 0.4.4

package/dist/main.js

@@ -112,7 +112,7 @@ var encodeProjectIdFromSessionFilePath = (sessionFilePath) => {
 // src/server/core/project/services/ProjectMetaService.ts
 import { FileSystem as FileSystem2, Path as Path3 } from "@effect/platform";
 import { Context as Context4, Effect as Effect5, Layer as Layer5, Option, Ref as Ref3 } from "effect";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/server/lib/storage/FileCacheStorage/index.ts
 import { Context as Context3, Effect as Effect4, Layer as Layer4, Ref as Ref2, Runtime } from "effect";
@@ -245,7 +245,7 @@ var makeFileCacheStorageLayer = (storageKey, schema) => Layer4.effect(
 );
 
 // src/lib/conversation-schema/index.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/lib/conversation-schema/entry/AssistantEntrySchema.ts
 import { z as z10 } from "zod";
@@ -381,80 +381,99 @@ var FileHistorySnapshotEntrySchema = z11.object({
   isSnapshotUpdate: z11.boolean()
 });
 
-// src/lib/conversation-schema/entry/SummaryEntrySchema.ts
+// src/lib/conversation-schema/entry/QueueOperationEntrySchema.ts
 import { z as z12 } from "zod";
-var SummaryEntrySchema = z12.object({
-  type: z12.literal("summary"),
-  summary: z12.string(),
-  leafUuid: z12.string().uuid()
+var QueueOperationEntrySchema = z12.union([
+  z12.object({
+    type: z12.literal("queue-operation"),
+    operation: z12.literal("enqueue"),
+    content: z12.string(),
+    sessionId: z12.string(),
+    timestamp: z12.iso.datetime()
+  }),
+  z12.object({
+    type: z12.literal("queue-operation"),
+    operation: z12.literal("dequeue"),
+    sessionId: z12.string(),
+    timestamp: z12.iso.datetime()
+  })
+]);
+
+// src/lib/conversation-schema/entry/SummaryEntrySchema.ts
+import { z as z13 } from "zod";
+var SummaryEntrySchema = z13.object({
+  type: z13.literal("summary"),
+  summary: z13.string(),
+  leafUuid: z13.string().uuid()
 });
 
 // src/lib/conversation-schema/entry/SystemEntrySchema.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var SystemEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z13.literal("system"),
+  type: z14.literal("system"),
   // required
-  content: z13.string(),
-  toolUseID: z13.string(),
-  level: z13.enum(["info"])
+  content: z14.string(),
+  toolUseID: z14.string(),
+  level: z14.enum(["info"])
 });
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/lib/conversation-schema/message/UserMessageSchema.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/lib/conversation-schema/content/DocumentContentSchema.ts
-import { z as z14 } from "zod";
-var DocumentContentSchema = z14.object({
-  type: z14.literal("document"),
-  source: z14.union([
-    z14.object({
-      media_type: z14.literal("text/plain"),
-      type: z14.literal("text"),
-      data: z14.string()
+import { z as z15 } from "zod";
+var DocumentContentSchema = z15.object({
+  type: z15.literal("document"),
+  source: z15.union([
+    z15.object({
+      media_type: z15.literal("text/plain"),
+      type: z15.literal("text"),
+      data: z15.string()
     }),
-    z14.object({
-      media_type: z14.enum(["application/pdf"]),
-      type: z14.literal("base64"),
-      data: z14.string()
+    z15.object({
+      media_type: z15.enum(["application/pdf"]),
+      type: z15.literal("base64"),
+      data: z15.string()
     })
   ])
 });
 
 // src/lib/conversation-schema/message/UserMessageSchema.ts
-var UserMessageContentSchema = z15.union([
-  z15.string(),
+var UserMessageContentSchema = z16.union([
+  z16.string(),
   TextContentSchema,
   ToolResultContentSchema,
   ImageContentSchema,
   DocumentContentSchema
 ]);
-var UserMessageSchema = z15.object({
-  role: z15.literal("user"),
-  content: z15.union([
-    z15.string(),
-    z15.array(z15.union([z15.string(), UserMessageContentSchema]))
+var UserMessageSchema = z16.object({
+  role: z16.literal("user"),
+  content: z16.union([
+    z16.string(),
+    z16.array(z16.union([z16.string(), UserMessageContentSchema]))
   ])
 });
 
 // src/lib/conversation-schema/entry/UserEntrySchema.ts
 var UserEntrySchema = BaseEntrySchema.extend({
   // discriminator
-  type: z16.literal("user"),
+  type: z17.literal("user"),
   // required
   message: UserMessageSchema
 });
 
 // src/lib/conversation-schema/index.ts
-var ConversationSchema = z17.union([
+var ConversationSchema = z18.union([
   UserEntrySchema,
   AssistantEntrySchema,
   SummaryEntrySchema,
   SystemEntrySchema,
-  FileHistorySnapshotEntrySchema
+  FileHistorySnapshotEntrySchema,
+  QueueOperationEntrySchema
 ]);
 
 // src/server/core/claude-code/functions/parseJsonl.ts
@@ -475,7 +494,7 @@ var parseJsonl = (content) => {
 };
 
 // src/server/core/project/services/ProjectMetaService.ts
-var ProjectPathSchema = z18.string().nullable();
+var ProjectPathSchema = z19.string().nullable();
 var LayerImpl4 = Effect5.gen(function* () {
   const fs = yield* FileSystem2.FileSystem;
   const path = yield* Path3.Path;
@@ -491,7 +510,7 @@ var LayerImpl4 = Effect5.gen(function* () {
     let cwd = null;
     for (const line of lines) {
       const conversation = parseJsonl(line).at(0);
-      if (conversation === void 0 || conversation.type === "summary" || conversation.type === "x-error" || conversation.type === "file-history-snapshot") {
+      if (conversation === void 0 || conversation.type === "summary" || conversation.type === "x-error" || conversation.type === "file-history-snapshot" || conversation.type === "queue-operation") {
         continue;
       }
       cwd = conversation.cwd;
@@ -649,12 +668,12 @@ var ProjectRepository = class extends Context5.Tag("ProjectRepository")() {
 };
 
 // src/server/core/claude-code/models/ClaudeCodeVersion.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var versionRegex = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)/;
-var versionSchema = z19.object({
-  major: z19.string().transform((value) => Number.parseInt(value, 10)),
-  minor: z19.string().transform((value) => Number.parseInt(value, 10)),
-  patch: z19.string().transform((value) => Number.parseInt(value, 10))
+var versionSchema = z20.object({
+  major: z20.string().transform((value) => Number.parseInt(value, 10)),
+  minor: z20.string().transform((value) => Number.parseInt(value, 10)),
+  patch: z20.string().transform((value) => Number.parseInt(value, 10))
 }).refine(
   (data) => [data.major, data.minor, data.patch].every((value) => !Number.isNaN(value))
 );
@@ -700,7 +719,9 @@ var parseMcpListOutput = (output) => {
 
 // src/server/core/claude-code/models/ClaudeCode.ts
 import { query as agentSdkQuery } from "@anthropic-ai/claude-agent-sdk";
-import { query as claudeCodeQuery } from "@anthropic-ai/claude-code";
+import {
+  query as claudeCodeQuery
+} from "@anthropic-ai/claude-code";
 import { Command, Path as Path5 } from "@effect/platform";
 import { Data, Effect as Effect7 } from "effect";
 var ClaudeCodePathNotFoundError = class extends Data.TaggedError(
@@ -818,9 +839,27 @@ var query = (prompt, options) => {
         }
       });
     }
+    const fallbackCanUseTool = (() => {
+      const canUseTool2 = options2.canUseTool;
+      if (canUseTool2 === void 0) {
+        return void 0;
+      }
+      const fn = async (toolName, input, canUseToolOptions) => {
+        const response = await canUseTool2(toolName, input, {
+          signal: canUseToolOptions.signal,
+          suggestions: canUseToolOptions.suggestions,
+          toolUseID: void 0
+        });
+        return response;
+      };
+      return fn;
+    })();
     return claudeCodeQuery({
       prompt,
-      options: options2
+      options: {
+        ...options2,
+        canUseTool: fallbackCanUseTool
+      }
     });
   });
 };
@@ -1145,7 +1184,7 @@ import { Context as Context11, Effect as Effect13, Layer as Layer12, Ref as Ref5
 var LayerImpl10 = Effect13.gen(function* () {
   const configRef = yield* Ref5.make({
     hideNoUserMessageSession: true,
-    unifySameTitleSession: true,
+    unifySameTitleSession: false,
     enterKeyBehavior: "shift-enter-send",
     permissionMode: "default",
     locale: "ja",
@@ -1204,26 +1243,26 @@ import { FileSystem as FileSystem6, Path as Path7 } from "@effect/platform";
 import { Context as Context14, Effect as Effect16, Layer as Layer15, Option as Option3 } from "effect";
 
 // src/server/core/claude-code/functions/parseUserMessage.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var regExp = /<(?<tag>[^>]+)>(?<content>\s*[^<]*?\s*)<\/\k<tag>>/g;
-var matchSchema = z20.object({
-  tag: z20.string(),
-  content: z20.string()
+var matchSchema = z21.object({
+  tag: z21.string(),
+  content: z21.string()
 });
-var parsedUserMessageSchema = z20.union([
-  z20.object({
-    kind: z20.literal("command"),
-    commandName: z20.string(),
-    commandArgs: z20.string().optional(),
-    commandMessage: z20.string().optional()
+var parsedUserMessageSchema = z21.union([
+  z21.object({
+    kind: z21.literal("command"),
+    commandName: z21.string(),
+    commandArgs: z21.string().optional(),
+    commandMessage: z21.string().optional()
   }),
-  z20.object({
-    kind: z20.literal("local-command"),
-    stdout: z20.string()
+  z21.object({
+    kind: z21.literal("local-command"),
+    stdout: z21.string()
   }),
-  z20.object({
-    kind: z20.literal("text"),
-    content: z20.string()
+  z21.object({
+    kind: z21.literal("text"),
+    content: z21.string()
   })
 ]);
 var parseUserMessage = (content) => {
@@ -1741,6 +1780,31 @@ var createMessageGenerator = () => {
   };
 };
 
+// src/server/core/claude-code/functions/fallbackSdkMessage.ts
+var fallbackSdkMessage = (message) => {
+  if (message.type === "system") {
+    if (message.subtype === "init") {
+      return {
+        ...message,
+        plugins: []
+      };
+    }
+    return message;
+  }
+  if (message.type === "result") {
+    if (message.subtype === "success") {
+      return {
+        ...message
+      };
+    }
+    return {
+      ...message,
+      errors: []
+    };
+  }
+  return message;
+};
+
 // src/server/core/claude-code/models/CCSessionProcess.ts
 import { Effect as Effect17 } from "effect";
 var isPublic = (process2) => {
@@ -2318,19 +2382,9 @@ var LayerImpl13 = Effect19.gen(function* () {
         setNextMessage(input);
         try {
           for await (const message of messageIter) {
-            if (message.type === "system" && message.subtype === "hook_response") {
-              continue;
-            }
-            if (message.type === "system" && message.subtype === "compact_boundary") {
-              continue;
-            }
+            const fallbackMessage = fallbackSdkMessage(message);
             const result = await Runtime2.runPromise(runtime)(
-              handleMessage(
-                message.type === "system" ? {
-                  ...message,
-                  plugins: []
-                } : message
-              )
+              handleMessage(fallbackMessage)
             ).catch((error) => {
               Effect19.runFork(
                 sessionProcessService.changeTaskState({
@@ -2675,11 +2729,11 @@ var SSEController = class extends Context19.Tag("SSEController")() {
 import { watch } from "node:fs";
 import { Path as Path8 } from "@effect/platform";
 import { Context as Context20, Effect as Effect23, Layer as Layer21, Ref as Ref9 } from "effect";
-import z21 from "zod";
+import z22 from "zod";
 var fileRegExp = /(?<projectId>.*?)\/(?<sessionId>.*?)\.jsonl/;
-var fileRegExpGroupSchema = z21.object({
-  projectId: z21.string(),
-  sessionId: z21.string()
+var fileRegExpGroupSchema = z22.object({
+  projectId: z22.string(),
+  sessionId: z22.string()
 });
 var FileWatcherService = class extends Context20.Tag("FileWatcherService")() {
   static {
@@ -3605,6 +3659,114 @@ var LayerImpl18 = Effect26.gen(function* () {
     console.log("[GitService.push] Push succeeded");
     return { branch, output: "success" };
   });
+  const getBranchHash = (cwd, branchName) => Effect26.gen(function* () {
+    const result = yield* execGitCommand(["rev-parse", branchName], cwd).pipe(
+      Effect26.map((output) => output.trim().split("\n")[0] ?? null)
+    );
+    return result;
+  });
+  const getBranchNamesByCommitHash = (cwd, hash) => Effect26.gen(function* () {
+    const result = yield* execGitCommand(
+      ["branch", "--contains", hash, "--format=%(refname:short)"],
+      cwd
+    );
+    return result.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  });
+  const compareCommitHash = (cwd, targetHash, compareHash) => Effect26.gen(function* () {
+    const aheadResult = yield* execGitCommand(
+      ["rev-list", `${targetHash}..${compareHash}`],
+      cwd
+    );
+    const aheadCounts = aheadResult.split("\n").map((line) => line.trim()).filter((line) => line !== "").length;
+    const behindResult = yield* execGitCommand(
+      ["rev-list", `${compareHash}..${targetHash}`],
+      cwd
+    );
+    const behindCounts = behindResult.split("\n").map((line) => line.trim()).filter((line) => line !== "").length;
+    if (aheadCounts === 0 && behindCounts === 0) {
+      return "un-related";
+    }
+    if (aheadCounts > 0) {
+      return "ahead";
+    }
+    if (behindCounts > 0) {
+      return "behind";
+    }
+    return "un-related";
+  });
+  const getCommitsWithParent = (cwd, options) => Effect26.gen(function* () {
+    const { offset, limit } = options;
+    const result = yield* execGitCommand(
+      [
+        "log",
+        "-n",
+        String(limit),
+        "--skip",
+        String(offset),
+        "--graph",
+        "--pretty=format:%h %p"
+      ],
+      cwd
+    );
+    const lines = result.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+    const commits = [];
+    for (const line of lines) {
+      const match = /^\* (?<current>.+) (?<parent>.+)$/.exec(line);
+      if (match?.groups?.current && match.groups.parent) {
+        commits.push({
+          current: match.groups.current,
+          parent: match.groups.parent
+        });
+      }
+    }
+    return commits;
+  });
+  const findBaseBranch = (cwd, targetBranch) => Effect26.gen(function* () {
+    let offset = 0;
+    const limit = 20;
+    while (offset < 100) {
+      const commits = yield* getCommitsWithParent(cwd, { offset, limit });
+      for (const commit2 of commits) {
+        const branchNames = yield* getBranchNamesByCommitHash(
+          cwd,
+          commit2.current
+        );
+        if (!branchNames.includes(targetBranch)) {
+          continue;
+        }
+        const otherBranchNames = branchNames.filter(
+          (branchName) => branchName !== targetBranch
+        );
+        if (otherBranchNames.length === 0) {
+          continue;
+        }
+        for (const branchName of otherBranchNames) {
+          const comparison = yield* compareCommitHash(
+            cwd,
+            targetBranch,
+            branchName
+          );
+          if (comparison === "behind") {
+            return { branch: branchName, hash: commit2.current };
+          }
+        }
+      }
+      offset += limit;
+    }
+    return null;
+  });
+  const getCommitsBetweenBranches = (cwd, baseBranch, targetBranch) => Effect26.gen(function* () {
+    const result = yield* execGitCommand(
+      [
+        "log",
+        `${baseBranch}..${targetBranch}`,
+        "--format=%H|%s|%an|%ad",
+        "--date=iso"
+      ],
+      cwd
+    );
+    return parseGitCommitsOutput(result);
+  });
   return {
     getBranches,
     getCurrentBranch,
@@ -3612,7 +3774,13 @@ var LayerImpl18 = Effect26.gen(function* () {
     getCommits,
     stageFiles,
     commit,
-    push
+    push,
+    getBranchHash,
+    getBranchNamesByCommitHash,
+    compareCommitHash,
+    getCommitsWithParent,
+    findBaseBranch,
+    getCommitsBetweenBranches
   };
 });
 var GitService = class extends Context23.Tag("GitService")() {
@@ -3625,56 +3793,6 @@ var GitService = class extends Context23.Tag("GitService")() {
 var LayerImpl19 = Effect27.gen(function* () {
   const gitService = yield* GitService;
   const projectRepository = yield* ProjectRepository;
-  const getGitBranches = (options) => Effect27.gen(function* () {
-    const { projectId } = options;
-    const { project } = yield* projectRepository.getProject(projectId);
-    if (project.meta.projectPath === null) {
-      return {
-        response: { error: "Project path not found" },
-        status: 400
-      };
-    }
-    const projectPath = project.meta.projectPath;
-    const branches = yield* Effect27.either(
-      gitService.getBranches(projectPath)
-    );
-    if (Either2.isLeft(branches)) {
-      return {
-        response: {
-          success: false
-        },
-        status: 200
-      };
-    }
-    return {
-      response: branches.right,
-      status: 200
-    };
-  });
-  const getGitCommits = (options) => Effect27.gen(function* () {
-    const { projectId } = options;
-    const { project } = yield* projectRepository.getProject(projectId);
-    if (project.meta.projectPath === null) {
-      return {
-        response: { error: "Project path not found" },
-        status: 400
-      };
-    }
-    const projectPath = project.meta.projectPath;
-    const commits = yield* Effect27.either(gitService.getCommits(projectPath));
-    if (Either2.isLeft(commits)) {
-      return {
-        response: {
-          success: false
-        },
-        status: 200
-      };
-    }
-    return {
-      response: commits.right,
-      status: 200
-    };
-  });
   const getGitDiff = (options) => Effect27.gen(function* () {
     const { projectId, fromRef, toRef } = options;
     const { project } = yield* projectRepository.getProject(projectId);
@@ -3869,13 +3987,86 @@ var LayerImpl19 = Effect27.gen(function* () {
       status: 200
     };
   });
+  const getCurrentRevisions = (options) => Effect27.gen(function* () {
+    const { projectId } = options;
+    const { project } = yield* projectRepository.getProject(projectId);
+    if (project.meta.projectPath === null) {
+      return {
+        response: { error: "Project path not found" },
+        status: 400
+      };
+    }
+    const projectPath = project.meta.projectPath;
+    const currentBranchResult = yield* Effect27.either(
+      gitService.getCurrentBranch(projectPath)
+    );
+    if (Either2.isLeft(currentBranchResult)) {
+      return {
+        response: {
+          success: false
+        },
+        status: 200
+      };
+    }
+    const currentBranch = currentBranchResult.right;
+    const baseBranchResult = yield* Effect27.either(
+      gitService.findBaseBranch(projectPath, currentBranch)
+    );
+    const allBranchesResult = yield* Effect27.either(
+      gitService.getBranches(projectPath)
+    );
+    if (Either2.isLeft(allBranchesResult)) {
+      return {
+        response: {
+          success: false
+        },
+        status: 200
+      };
+    }
+    const allBranches = allBranchesResult.right.data;
+    const currentBranchDetails = allBranches.find(
+      (branch) => branch.name === currentBranch
+    );
+    let baseBranchDetails;
+    if (Either2.isRight(baseBranchResult) && baseBranchResult.right !== null) {
+      const baseBranchName = baseBranchResult.right.branch;
+      baseBranchDetails = allBranches.find(
+        (branch) => branch.name === baseBranchName
+      );
+    }
+    let commits = [];
+    if (Either2.isRight(baseBranchResult) && baseBranchResult.right !== null) {
+      const baseBranchHash = baseBranchResult.right.hash;
+      const commitsResult = yield* Effect27.either(
+        gitService.getCommitsBetweenBranches(
+          projectPath,
+          baseBranchHash,
+          "HEAD"
+        )
+      );
+      if (Either2.isRight(commitsResult)) {
+        commits = commitsResult.right.data;
+      }
+    }
+    return {
+      response: {
+        success: true,
+        data: {
+          baseBranch: baseBranchDetails ?? null,
+          currentBranch: currentBranchDetails ?? null,
+          head: currentBranchDetails?.commit ?? null,
+          commits
+        }
+      },
+      status: 200
+    };
+  });
   return {
-    getGitBranches,
-    getGitCommits,
     getGitDiff,
     commitFiles,
     pushCommits,
-    commitAndPush
+    commitAndPush,
+    getCurrentRevisions
   };
 });
 function parsePushError(stderr) {
@@ -4062,39 +4253,39 @@ import { FileSystem as FileSystem9, Path as Path12 } from "@effect/platform";
 import { Context as Context26, Data as Data5, Effect as Effect30, Layer as Layer27 } from "effect";
 
 // src/server/core/scheduler/schema.ts
-import { z as z22 } from "zod";
-var concurrencyPolicySchema = z22.enum(["skip", "run"]);
-var cronScheduleSchema = z22.object({
-  type: z22.literal("cron"),
-  expression: z22.string(),
+import { z as z23 } from "zod";
+var concurrencyPolicySchema = z23.enum(["skip", "run"]);
+var cronScheduleSchema = z23.object({
+  type: z23.literal("cron"),
+  expression: z23.string(),
   concurrencyPolicy: concurrencyPolicySchema
 });
-var reservedScheduleSchema = z22.object({
-  type: z22.literal("reserved"),
-  reservedExecutionTime: z22.iso.datetime()
+var reservedScheduleSchema = z23.object({
+  type: z23.literal("reserved"),
+  reservedExecutionTime: z23.iso.datetime()
 });
-var scheduleSchema = z22.discriminatedUnion("type", [
+var scheduleSchema = z23.discriminatedUnion("type", [
   cronScheduleSchema,
   reservedScheduleSchema
 ]);
-var messageConfigSchema = z22.object({
-  content: z22.string(),
-  projectId: z22.string(),
-  baseSessionId: z22.string().nullable()
+var messageConfigSchema = z23.object({
+  content: z23.string(),
+  projectId: z23.string(),
+  baseSessionId: z23.string().nullable()
 });
-var jobStatusSchema = z22.enum(["success", "failed"]);
-var schedulerJobSchema = z22.object({
-  id: z22.string(),
-  name: z22.string(),
+var jobStatusSchema = z23.enum(["success", "failed"]);
+var schedulerJobSchema = z23.object({
+  id: z23.string(),
+  name: z23.string(),
   schedule: scheduleSchema,
   message: messageConfigSchema,
-  enabled: z22.boolean(),
-  createdAt: z22.string().datetime(),
-  lastRunAt: z22.string().datetime().nullable(),
+  enabled: z23.boolean(),
+  createdAt: z23.string().datetime(),
+  lastRunAt: z23.string().datetime().nullable(),
   lastRunStatus: jobStatusSchema.nullable()
 });
-var schedulerConfigSchema = z22.object({
-  jobs: z22.array(schedulerJobSchema)
+var schedulerConfigSchema = z23.object({
+  jobs: z23.array(schedulerJobSchema)
 });
 var newSchedulerJobSchema = schedulerJobSchema.omit({
   id: true,
@@ -4102,7 +4293,7 @@ var newSchedulerJobSchema = schedulerJobSchema.omit({
   lastRunAt: true,
   lastRunStatus: true
 }).extend({
-  enabled: z22.boolean().default(true)
+  enabled: z23.boolean().default(true)
 });
 var updateSchedulerJobSchema = schedulerJobSchema.partial().pick({
   name: true,
@@ -4680,12 +4871,12 @@ import { Effect as Effect37, Runtime as Runtime3 } from "effect";
 import { setCookie as setCookie2 } from "hono/cookie";
 import { streamSSE } from "hono/streaming";
 import prexit from "prexit";
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // package.json
 var package_default = {
   name: "@kimuson/claude-code-viewer",
-  version: "0.4.2-beta.2",
+  version: "0.4.3",
   type: "module",
   license: "MIT",
   repository: {
@@ -4722,10 +4913,11 @@ var package_default = {
     e2e: "./scripts/e2e/exec_e2e.sh",
     "e2e:start-server": "./scripts/e2e/start_server.sh",
     "e2e:capture-snapshots": "./scripts/e2e/capture_snapshots.sh",
+    "lingui:extract": "lingui extract --clean",
     "lingui:compile": "lingui compile --typescript"
   },
   dependencies: {
-    "@anthropic-ai/claude-agent-sdk": "0.1.27",
+    "@anthropic-ai/claude-agent-sdk": "0.1.30",
     "@anthropic-ai/claude-code": "2.0.24",
     "@anthropic-ai/sdk": "0.67.0",
     "@effect/platform": "0.92.1",
@@ -4739,6 +4931,7 @@ var package_default = {
     "@radix-ui/react-collapsible": "1.1.12",
     "@radix-ui/react-dialog": "1.1.15",
     "@radix-ui/react-hover-card": "1.1.15",
+    "@radix-ui/react-popover": "^1.1.15",
     "@radix-ui/react-select": "2.2.6",
     "@radix-ui/react-slot": "1.2.3",
     "@radix-ui/react-tabs": "1.1.13",
@@ -4802,49 +4995,62 @@ var package_default = {
 };
 
 // src/server/core/claude-code/schema.ts
-import { z as z23 } from "zod";
-var imageBlockSchema = z23.object({
-  type: z23.literal("image"),
-  source: z23.object({
-    type: z23.literal("base64"),
-    media_type: z23.enum(["image/png", "image/jpeg", "image/gif", "image/webp"]),
-    data: z23.string()
+import { z as z24 } from "zod";
+var mediaTypeSchema = z24.enum([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+]);
+var imageBlockSchema = z24.object({
+  type: z24.literal("image"),
+  source: z24.object({
+    type: z24.literal("base64"),
+    media_type: mediaTypeSchema,
+    data: z24.string()
   })
 });
-var documentBlockSchema = z23.object({
-  type: z23.literal("document"),
-  source: z23.object({
-    type: z23.literal("base64"),
-    media_type: z23.enum(["application/pdf"]),
-    data: z23.string()
-  })
+var documentBlockSchema = z24.object({
+  type: z24.literal("document"),
+  source: z24.union([
+    z24.object({
+      type: z24.literal("text"),
+      media_type: z24.enum(["text/plain"]),
+      data: z24.string()
+    }),
+    z24.object({
+      type: z24.literal("base64"),
+      media_type: z24.enum(["application/pdf"]),
+      data: z24.string()
+    })
+  ])
 });
-var userMessageInputSchema = z23.object({
-  text: z23.string().min(1),
-  images: z23.array(imageBlockSchema).optional(),
-  documents: z23.array(documentBlockSchema).optional()
+var userMessageInputSchema = z24.object({
+  text: z24.string().min(1),
+  images: z24.array(imageBlockSchema).optional(),
+  documents: z24.array(documentBlockSchema).optional()
 });
 
 // src/server/core/git/schema.ts
-import { z as z24 } from "zod";
-var CommitRequestSchema = z24.object({
-  projectId: z24.string().min(1),
-  files: z24.array(z24.string().min(1)).min(1),
-  message: z24.string().trim().min(1)
+import { z as z25 } from "zod";
+var CommitRequestSchema = z25.object({
+  projectId: z25.string().min(1),
+  files: z25.array(z25.string().min(1)).min(1),
+  message: z25.string().trim().min(1)
 });
-var PushRequestSchema = z24.object({
-  projectId: z24.string().min(1)
+var PushRequestSchema = z25.object({
+  projectId: z25.string().min(1)
 });
-var CommitResultSuccessSchema = z24.object({
-  success: z24.literal(true),
-  commitSha: z24.string().length(40),
-  filesCommitted: z24.number().int().positive(),
-  message: z24.string()
+var CommitResultSuccessSchema = z25.object({
+  success: z25.literal(true),
+  commitSha: z25.string().length(40),
+  filesCommitted: z25.number().int().positive(),
+  message: z25.string()
 });
-var CommitResultErrorSchema = z24.object({
-  success: z24.literal(false),
-  error: z24.string(),
-  errorCode: z24.enum([
+var CommitResultErrorSchema = z25.object({
+  success: z25.literal(false),
+  error: z25.string(),
+  errorCode: z25.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -4852,22 +5058,22 @@ var CommitResultErrorSchema = z24.object({
     "HOOK_FAILED",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z24.string().optional()
+  details: z25.string().optional()
 });
-var CommitResultSchema = z24.discriminatedUnion("success", [
+var CommitResultSchema = z25.discriminatedUnion("success", [
   CommitResultSuccessSchema,
   CommitResultErrorSchema
 ]);
-var PushResultSuccessSchema = z24.object({
-  success: z24.literal(true),
-  remote: z24.string(),
-  branch: z24.string(),
-  objectsPushed: z24.number().int().optional()
+var PushResultSuccessSchema = z25.object({
+  success: z25.literal(true),
+  remote: z25.string(),
+  branch: z25.string(),
+  objectsPushed: z25.number().int().optional()
 });
-var PushResultErrorSchema = z24.object({
-  success: z24.literal(false),
-  error: z24.string(),
-  errorCode: z24.enum([
+var PushResultErrorSchema = z25.object({
+  success: z25.literal(false),
+  error: z25.string(),
+  errorCode: z25.enum([
     "PROJECT_NOT_FOUND",
     "NOT_A_REPOSITORY",
     "NO_UPSTREAM",
@@ -4877,26 +5083,26 @@ var PushResultErrorSchema = z24.object({
     "TIMEOUT",
     "GIT_COMMAND_ERROR"
   ]),
-  details: z24.string().optional()
+  details: z25.string().optional()
 });
-var PushResultSchema = z24.discriminatedUnion("success", [
+var PushResultSchema = z25.discriminatedUnion("success", [
   PushResultSuccessSchema,
   PushResultErrorSchema
 ]);
-var CommitAndPushResultSuccessSchema = z24.object({
-  success: z24.literal(true),
-  commitSha: z24.string().length(40),
-  filesCommitted: z24.number().int().positive(),
-  message: z24.string(),
-  remote: z24.string(),
-  branch: z24.string()
+var CommitAndPushResultSuccessSchema = z25.object({
+  success: z25.literal(true),
+  commitSha: z25.string().length(40),
+  filesCommitted: z25.number().int().positive(),
+  message: z25.string(),
+  remote: z25.string(),
+  branch: z25.string()
 });
-var CommitAndPushResultErrorSchema = z24.object({
-  success: z24.literal(false),
-  commitSucceeded: z24.boolean(),
-  commitSha: z24.string().length(40).optional(),
-  error: z24.string(),
-  errorCode: z24.enum([
+var CommitAndPushResultErrorSchema = z25.object({
+  success: z25.literal(false),
+  commitSucceeded: z25.boolean(),
+  commitSha: z25.string().length(40).optional(),
+  error: z25.string(),
+  errorCode: z25.enum([
     "EMPTY_MESSAGE",
     "NO_FILES",
     "PROJECT_NOT_FOUND",
@@ -4909,28 +5115,28 @@ var CommitAndPushResultErrorSchema = z24.object({
     "NETWORK_ERROR",
     "TIMEOUT"
   ]),
-  details: z24.string().optional()
+  details: z25.string().optional()
 });
-var CommitAndPushResultSchema = z24.discriminatedUnion("success", [
+var CommitAndPushResultSchema = z25.discriminatedUnion("success", [
   CommitAndPushResultSuccessSchema,
   CommitAndPushResultErrorSchema
 ]);
 
 // src/server/lib/config/config.ts
-import z26 from "zod";
+import z27 from "zod";
 
 // src/lib/i18n/schema.ts
-import z25 from "zod";
-var localeSchema = z25.enum(["ja", "en"]);
+import z26 from "zod";
+var localeSchema = z26.enum(["ja", "en", "zh_CN"]);
 
 // src/server/lib/config/config.ts
-var userConfigSchema = z26.object({
-  hideNoUserMessageSession: z26.boolean().optional().default(true),
-  unifySameTitleSession: z26.boolean().optional().default(true),
-  enterKeyBehavior: z26.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
-  permissionMode: z26.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
+var userConfigSchema = z27.object({
+  hideNoUserMessageSession: z27.boolean().optional().default(true),
+  unifySameTitleSession: z27.boolean().optional().default(false),
+  enterKeyBehavior: z27.enum(["shift-enter-send", "enter-send", "command-enter-send"]).optional().default("shift-enter-send"),
+  permissionMode: z27.enum(["acceptEdits", "bypassPermissions", "default", "plan"]).optional().default("default"),
   locale: localeSchema.optional().default("en"),
-  theme: z26.enum(["light", "dark", "system"]).optional().default("system")
+  theme: z27.enum(["light", "dark", "system"]).optional().default("system")
 });
 
 // src/server/lib/effect/toEffectResponse.ts
@@ -5033,7 +5239,7 @@ var routes = (app) => Effect37.gen(function* () {
     return response;
   }).get(
     "/api/projects/:projectId",
-    zValidator("query", z27.object({ cursor: z27.string().optional() })),
+    zValidator("query", z28.object({ cursor: z28.string().optional() })),
     async (c) => {
       const response = await effectToResponse(
         c,
@@ -5048,8 +5254,8 @@ var routes = (app) => Effect37.gen(function* () {
     "/api/projects",
     zValidator(
       "json",
-      z27.object({
-        projectPath: z27.string().min(1, "Project path is required")
+      z28.object({
+        projectPath: z28.string().min(1, "Project path is required")
       })
     ),
     async (c) => {
@@ -5075,18 +5281,10 @@ var routes = (app) => Effect37.gen(function* () {
       sessionController.getSession({ ...c.req.param() }).pipe(Effect37.provide(runtime))
     );
     return response;
-  }).get("/api/projects/:projectId/git/branches", async (c) => {
-    const response = await effectToResponse(
-      c,
-      gitController.getGitBranches({
-        ...c.req.param()
-      }).pipe(Effect37.provide(runtime))
-    );
-    return response;
-  }).get("/api/projects/:projectId/git/commits", async (c) => {
+  }).get("/api/projects/:projectId/git/current-revisions", async (c) => {
     const response = await effectToResponse(
       c,
-      gitController.getGitCommits({
+      gitController.getCurrentRevisions({
         ...c.req.param()
       }).pipe(Effect37.provide(runtime))
     );
@@ -5095,9 +5293,9 @@ var routes = (app) => Effect37.gen(function* () {
     "/api/projects/:projectId/git/diff",
     zValidator(
       "json",
-      z27.object({
-        fromRef: z27.string().min(1, "fromRef is required"),
-        toRef: z27.string().min(1, "toRef is required")
+      z28.object({
+        fromRef: z28.string().min(1, "fromRef is required"),
+        toRef: z28.string().min(1, "toRef is required")
       })
     ),
     async (c) => {
@@ -5187,10 +5385,10 @@ var routes = (app) => Effect37.gen(function* () {
     "/api/cc/session-processes",
     zValidator(
       "json",
-      z27.object({
-        projectId: z27.string(),
+      z28.object({
+        projectId: z28.string(),
         input: userMessageInputSchema,
-        baseSessionId: z27.string().optional()
+        baseSessionId: z28.string().optional()
       })
     ),
     async (c) => {
@@ -5206,10 +5404,10 @@ var routes = (app) => Effect37.gen(function* () {
     "/api/cc/session-processes/:sessionProcessId/continue",
     zValidator(
       "json",
-      z27.object({
-        projectId: z27.string(),
+      z28.object({
+        projectId: z28.string(),
         input: userMessageInputSchema,
-        baseSessionId: z27.string()
+        baseSessionId: z28.string()
       })
     ),
     async (c) => {
@@ -5224,7 +5422,7 @@ var routes = (app) => Effect37.gen(function* () {
     }
   ).post(
     "/api/cc/session-processes/:sessionProcessId/abort",
-    zValidator("json", z27.object({ projectId: z27.string() })),
+    zValidator("json", z28.object({ projectId: z28.string() })),
     async (c) => {
       const { sessionProcessId } = c.req.param();
       void Effect37.runFork(
@@ -5236,9 +5434,9 @@ var routes = (app) => Effect37.gen(function* () {
     "/api/cc/permission-response",
     zValidator(
       "json",
-      z27.object({
-        permissionRequestId: z27.string(),
-        decision: z27.enum(["allow", "deny"])
+      z28.object({
+        permissionRequestId: z28.string(),
+        decision: z28.enum(["allow", "deny"])
       })
     ),
     async (c) => {
@@ -5305,9 +5503,9 @@ var routes = (app) => Effect37.gen(function* () {
     "/api/fs/file-completion",
     zValidator(
       "query",
-      z27.object({
-        projectId: z27.string(),
-        basePath: z27.string().optional().default("/api/")
+      z28.object({
+        projectId: z28.string(),
+        basePath: z28.string().optional().default("/api/")
       })
     ),
     async (c) => {
@@ -5323,9 +5521,9 @@ var routes = (app) => Effect37.gen(function* () {
     "/api/fs/directory-browser",
     zValidator(
       "query",
-      z27.object({
-        currentPath: z27.string().optional(),
-        showHidden: z27.string().optional().transform((val) => val === "true")
+      z28.object({
+        currentPath: z28.string().optional(),
+        showHidden: z28.string().optional().transform((val) => val === "true")
       })
     ),
     async (c) => {