@tutti-os/workspace-issue-manager 0.0.1

package/dist/chunk-4B2P64PY.js

@@ -0,0 +1,938 @@
+import {
+  normalizeIssueManagerContent,
+  normalizeIssueManagerNodeState
+} from "./chunk-WJSZFKUD.js";
+
+// src/services/internal/model.ts
+import { formatNextopShortDateTime } from "@tutti-os/ui-system/date-format";
+function createIssueManagerDate(value) {
+  if (!value || !Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = value < 1e12 ? value * 1e3 : value;
+  const date = new Date(normalized);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function formatIssueManagerTimestamp(value) {
+  const date = createIssueManagerDate(value);
+  return date ? formatNextopShortDateTime(date) : null;
+}
+function formatIssueManagerDate(value) {
+  const date = createIssueManagerDate(value);
+  return date ? formatNextopShortDateTime(date) : "";
+}
+function resolveIssueManagerStatusLabel(copy, status) {
+  switch (status) {
+    case "not_started":
+      return copy.t("status.notStarted");
+    case "running":
+      return copy.t("status.running");
+    case "in_progress":
+      return copy.t("status.inProgress");
+    case "pending_acceptance":
+      return copy.t("status.pendingAcceptance");
+    case "completed":
+      return copy.t("status.completed");
+    case "failed":
+      return copy.t("status.failed");
+    case "canceled":
+      return copy.t("status.canceled");
+    default:
+      return copy.t("status.unknown");
+  }
+}
+function resolveIssueManagerPriorityLabel(copy, priority) {
+  switch (priority) {
+    case "high":
+      return copy.t("priority.high");
+    case "low":
+      return copy.t("priority.low");
+    default:
+      return copy.t("priority.medium");
+  }
+}
+function uniqueIssueManagerFileReferences(refs) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const normalizedPath = ref.path.trim();
+    if (!normalizedPath || unique.has(normalizedPath)) {
+      continue;
+    }
+    unique.set(normalizedPath, {
+      displayName: ref.displayName?.trim() || void 0,
+      kind: ref.kind === "folder" ? "folder" : "file",
+      path: normalizedPath
+    });
+  }
+  return [...unique.values()];
+}
+function parentDirectoryPath(path) {
+  const trimmed = path.trim();
+  if (!trimmed || trimmed === "/") {
+    return null;
+  }
+  const normalized = trimmed.endsWith("/") && trimmed.length > 1 ? trimmed.slice(0, -1) : trimmed;
+  const index = normalized.lastIndexOf("/");
+  if (index <= 0) {
+    return "/";
+  }
+  return normalized.slice(0, index) || "/";
+}
+
+// src/services/internal/controllerRuntime.ts
+import { proxy } from "valtio/vanilla";
+
+// src/services/internal/controllerUtils.ts
+var defaultTaskPriority = "medium";
+function resolveIssueManagerSelectedIssueId(currentSelectedIssueId, issues) {
+  if (currentSelectedIssueId && issues.some((issue) => issue.issueId === currentSelectedIssueId)) {
+    return currentSelectedIssueId;
+  }
+  return issues[0]?.issueId ?? null;
+}
+function resolveIssueManagerSelectedTaskId(currentSelectedTaskId, tasks) {
+  if (currentSelectedTaskId && tasks.some((task) => task.taskId === currentSelectedTaskId)) {
+    return currentSelectedTaskId;
+  }
+  return null;
+}
+function toContextRefInput(ref) {
+  return {
+    displayName: ref.displayName,
+    path: ref.path,
+    refType: ref.kind === "folder" ? "folder" : "file"
+  };
+}
+function toIssueManagerWorkspaceFileLinkInput(ref) {
+  return {
+    kind: ref.kind === "folder" ? "folder" : "file",
+    name: ref.displayName,
+    path: ref.path
+  };
+}
+function confirmIssueManagerMessage(message) {
+  try {
+    return globalThis.confirm?.(message) ?? true;
+  } catch {
+    return true;
+  }
+}
+function resolveIssueManagerErrorMessage(error, copy, fallbackKey) {
+  const raw = error instanceof Error ? error.message : typeof error === "string" ? error : String(error);
+  if (!copy) {
+    return raw;
+  }
+  if (raw === "issue_manager.upload_type_conflict") {
+    return copy.t("messages.uploadTypeConflict");
+  }
+  if (raw === "issue_manager.clipboard_unavailable") {
+    return copy.t("messages.clipboardUnavailable");
+  }
+  if (raw === "issue_manager.workspace_path_unavailable") {
+    return copy.t("messages.workspacePathUnavailable");
+  }
+  if (raw === "issue_manager.run_status_missing") {
+    return copy.t("messages.runStatusMissing");
+  }
+  if (raw === "issue_manager.run_timed_out") {
+    return copy.t("messages.runTimedOut");
+  }
+  if (raw.startsWith("issue_manager.run_exit_code:")) {
+    return copy.t("messages.runExitCode", {
+      code: raw.slice("issue_manager.run_exit_code:".length)
+    });
+  }
+  return fallbackKey ? copy.t(fallbackKey) : raw;
+}
+function resolveIssueManagerTopicDeleteErrorMessage(error, copy) {
+  const protocolError = extractProtocolErrorShape(error);
+  if (!protocolError) {
+    return resolveIssueManagerErrorMessage(
+      error,
+      copy,
+      "messages.topicDeleteFailed"
+    );
+  }
+  if (protocolError.reason === "workspace_issue_topic_not_empty") {
+    return copy.t("messages.topicDeleteNotEmpty");
+  }
+  if (protocolError.reason === "workspace_issue_topic_not_found") {
+    return copy.t("messages.topicDeleteNotFound");
+  }
+  if (protocolError.code === "invalid_request" && protocolError.reason === "malformed_request") {
+    return copy.t("messages.topicDeleteDefaultForbidden");
+  }
+  return copy.t("messages.topicDeleteFailed");
+}
+function extractProtocolErrorShape(error) {
+  if (isProtocolErrorShape(error)) {
+    return error;
+  }
+  if (typeof error !== "object" || error === null || !("error" in error)) {
+    return null;
+  }
+  const nestedError = error.error;
+  return isProtocolErrorShape(nestedError) ? nestedError : null;
+}
+function isProtocolErrorShape(value) {
+  return typeof value === "object" && value !== null && "code" in value && typeof value.code === "string" && (!("reason" in value) || typeof value.reason === "string" || typeof value.reason === "undefined");
+}
+
+// src/services/internal/controllerState.ts
+function createIssueManagerIssueDraftFromNodeState(state) {
+  return {
+    content: state?.issueDraftContent ?? "",
+    title: state?.issueDraftTitle ?? ""
+  };
+}
+function createIssueManagerTaskDraftFromNodeState(state, priority = defaultTaskPriority) {
+  return {
+    content: state?.taskDraftContent ?? "",
+    priority,
+    title: state?.taskDraftTitle ?? ""
+  };
+}
+function applyIssueManagerIssueSelection(current, issueId) {
+  return {
+    ...current,
+    selectedIssueId: issueId,
+    selectedTaskId: null
+  };
+}
+function applyIssueManagerTaskSelection(current, taskId) {
+  return {
+    ...current,
+    selectedTaskId: taskId
+  };
+}
+function applyIssueManagerIssueDeleted(current) {
+  return {
+    ...current,
+    selectedIssueId: null,
+    selectedTaskId: null
+  };
+}
+function applyIssueManagerTaskDeleted(current) {
+  return {
+    ...current,
+    selectedTaskId: null
+  };
+}
+function applyIssueManagerSelectedAgentProvider(current, provider) {
+  return {
+    ...current,
+    selectedAgentProvider: provider
+  };
+}
+function applyIssueManagerSelectedExecutionDirectory(current, executionDirectory) {
+  return {
+    ...current,
+    selectedExecutionDirectory: executionDirectory?.trim() || null
+  };
+}
+function applyIssueManagerIssueListResultToNodeState(current, result) {
+  return {
+    ...current,
+    issueListNextPageToken: result.nextPageToken ?? null,
+    selectedIssueId: resolveIssueManagerSelectedIssueId(
+      current.selectedIssueId,
+      result.issues
+    )
+  };
+}
+function applyIssueManagerIssueDetailResultToNodeState(current, detail) {
+  return {
+    ...current,
+    selectedTaskId: resolveIssueManagerSelectedTaskId(
+      current.selectedTaskId,
+      detail.tasks
+    )
+  };
+}
+function syncIssueManagerIssueDraftFromDetail(current, detail, editorMode) {
+  if (editorMode !== "read") {
+    return current;
+  }
+  return {
+    content: normalizeIssueManagerContent(detail?.issue.content ?? ""),
+    title: detail?.issue.title ?? ""
+  };
+}
+function syncIssueManagerTaskDraftFromDetail(current, detail, editorMode) {
+  if (editorMode !== "read") {
+    return current;
+  }
+  return {
+    content: normalizeIssueManagerContent(detail?.task.content ?? ""),
+    priority: detail?.task.priority ?? defaultTaskPriority,
+    title: detail?.task.title ?? ""
+  };
+}
+function applyIssueManagerIssueEditorModeToNodeState(current, editorMode) {
+  if (editorMode === "create") {
+    return current;
+  }
+  return {
+    ...current,
+    issueDraftContent: null,
+    issueDraftTitle: null
+  };
+}
+function applyIssueManagerTaskEditorModeToNodeState(current, editorMode) {
+  if (editorMode === "create") {
+    return current;
+  }
+  return {
+    ...current,
+    taskDraftContent: null,
+    taskDraftTitle: null
+  };
+}
+function applyIssueManagerIssueSaved(current, issueId) {
+  return {
+    ...current,
+    issueDraftContent: null,
+    issueDraftTitle: null,
+    selectedIssueId: issueId
+  };
+}
+function applyIssueManagerTaskSaved(current, taskId) {
+  return {
+    ...current,
+    selectedTaskId: taskId,
+    taskDraftContent: null,
+    taskDraftTitle: null
+  };
+}
+function persistIssueManagerIssueDraftContent(current, editorMode, content) {
+  if (editorMode !== "create") {
+    return current;
+  }
+  return {
+    ...current,
+    issueDraftContent: content
+  };
+}
+function persistIssueManagerTaskDraftContent(current, editorMode, content) {
+  if (editorMode !== "create") {
+    return current;
+  }
+  return {
+    ...current,
+    taskDraftContent: content
+  };
+}
+
+// src/services/internal/controllerRuntime.ts
+function createIssueManagerOpenedParams(source) {
+  return {
+    source,
+    trigger: source === "restore" || source === "agent_command" ? "automatic" : "manual"
+  };
+}
+function createIssueManagerControllerRuntime(input) {
+  const normalizedNodeState = normalizeIssueManagerNodeState(input.state);
+  const listeners = /* @__PURE__ */ new Set();
+  let deferredIssueSearch = normalizedNodeState.issueSearchQuery;
+  let issueDetailSequence = 0;
+  let issueListSequence = 0;
+  let lastResolvedIssueSearchQuery = null;
+  let hasReportedOpened = false;
+  let onStateChange;
+  let pendingIssueSearchAnalyticsQuery = null;
+  let refCount = 0;
+  let retained = false;
+  let taskDetailSequence = 0;
+  let topicListSequence = 0;
+  let unsubscribeIssueUpdates = null;
+  let snapshot = {
+    issueDetail: createAsyncCollectionState(
+      null
+    ),
+    issueDraft: createIssueManagerIssueDraftFromNodeState(normalizedNodeState),
+    issueEditorMode: "read",
+    issues: createAsyncCollectionState([], {
+      hasResolved: false
+    }),
+    isRunningTask: false,
+    nodeState: normalizedNodeState,
+    notification: null,
+    referenceTarget: null,
+    taskDetail: createAsyncCollectionState(null),
+    taskDraft: createIssueManagerTaskDraftFromNodeState(normalizedNodeState),
+    taskEditorMode: "read",
+    topics: createAsyncCollectionState([], {
+      hasResolved: false
+    })
+  };
+  const store = proxy(snapshot);
+  const notify = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const setSnapshot = (updater) => {
+    const next = typeof updater === "function" ? updater(snapshot) : {
+      ...snapshot,
+      ...updater
+    };
+    if (next === snapshot) {
+      return;
+    }
+    snapshot = next;
+    Object.assign(store, next);
+    notify();
+  };
+  const syncIssueDraftFromCurrentDetail = () => {
+    const nextIssueDraft = syncIssueManagerIssueDraftFromDetail(
+      snapshot.issueDraft,
+      snapshot.issueDetail.value,
+      snapshot.issueEditorMode
+    );
+    if (nextIssueDraft === snapshot.issueDraft) {
+      return;
+    }
+    setSnapshot((current) => ({
+      ...current,
+      issueDraft: nextIssueDraft
+    }));
+  };
+  const syncTaskDraftFromCurrentDetail = () => {
+    const nextTaskDraft = syncIssueManagerTaskDraftFromDetail(
+      snapshot.taskDraft,
+      snapshot.taskDetail.value,
+      snapshot.taskEditorMode
+    );
+    if (nextTaskDraft === snapshot.taskDraft) {
+      return;
+    }
+    setSnapshot((current) => ({
+      ...current,
+      taskDraft: nextTaskDraft
+    }));
+  };
+  const applyNodeState = (updater) => {
+    const previous = snapshot.nodeState;
+    const next = typeof updater === "function" ? updater(previous) : {
+      ...previous,
+      ...updater
+    };
+    if (next === previous) {
+      return;
+    }
+    setSnapshot((current) => ({
+      ...current,
+      nodeState: next
+    }));
+    onStateChange?.(next);
+    handleNodeStateTransition(previous, next);
+  };
+  const loadTopics = async () => {
+    const sequence = ++topicListSequence;
+    setSnapshot((current) => ({
+      ...current,
+      topics: {
+        ...current.topics,
+        error: null,
+        isLoading: true
+      }
+    }));
+    try {
+      const result = await input.feature.backend.listTopics({
+        workspaceId: input.workspaceId
+      });
+      if (!retained || sequence !== topicListSequence) {
+        return;
+      }
+      if (result.topics.length === 0) {
+        throw new Error(input.feature.i18n.t("messages.topicListEmpty"));
+      }
+      setSnapshot((current) => ({
+        ...current,
+        topics: {
+          error: null,
+          hasResolved: true,
+          isLoading: false,
+          value: result.topics
+        }
+      }));
+      const currentActiveTopicId = snapshot.nodeState.activeTopicId;
+      const currentTopicExists = result.topics.some(
+        (topic) => topic.topicId === currentActiveTopicId
+      );
+      const activeTopicId = currentTopicExists ? currentActiveTopicId : result.topics[0]?.topicId ?? null;
+      applyNodeState({
+        activeTopicId
+      });
+      if (activeTopicId && activeTopicId === currentActiveTopicId) {
+        void loadIssues();
+      }
+    } catch (error) {
+      if (!retained || sequence !== topicListSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        topics: {
+          error: resolveIssueManagerErrorMessage(error, input.feature.i18n),
+          hasResolved: true,
+          isLoading: false,
+          value: []
+        }
+      }));
+    }
+  };
+  const trackIssueSearchAnalytics = (inputValue, resultCount) => {
+    const query = inputValue.trim();
+    if (!query) {
+      return;
+    }
+    void Promise.resolve(
+      input.feature.analytics?.track({
+        name: "issue_manager.task_searched",
+        params: {
+          queryLength: query.length,
+          resultCount
+        }
+      })
+    ).catch(() => void 0);
+  };
+  const flushPendingIssueSearchAnalytics = (searchQuery, resultCount) => {
+    if (pendingIssueSearchAnalyticsQuery !== searchQuery || !searchQuery) {
+      return;
+    }
+    pendingIssueSearchAnalyticsQuery = null;
+    trackIssueSearchAnalytics(searchQuery, resultCount);
+  };
+  const loadIssues = async () => {
+    const searchQuery = deferredIssueSearch.trim();
+    const activeTopicId = snapshot.nodeState.activeTopicId;
+    const sequence = ++issueListSequence;
+    if (!activeTopicId) {
+      lastResolvedIssueSearchQuery = searchQuery;
+      setSnapshot((current) => ({
+        ...current,
+        issues: {
+          error: null,
+          hasResolved: true,
+          isLoading: false,
+          value: []
+        }
+      }));
+      flushPendingIssueSearchAnalytics(searchQuery, 0);
+      return;
+    }
+    setSnapshot((current) => ({
+      ...current,
+      issues: {
+        ...current.issues,
+        error: null,
+        isLoading: true
+      }
+    }));
+    try {
+      const result = await input.feature.backend.listIssues({
+        searchQuery: searchQuery || void 0,
+        statusFilter: snapshot.nodeState.issueStatusFilter,
+        topicId: activeTopicId,
+        workspaceId: input.workspaceId
+      });
+      if (!retained || sequence !== issueListSequence) {
+        return;
+      }
+      lastResolvedIssueSearchQuery = searchQuery;
+      setSnapshot((current) => ({
+        ...current,
+        issues: {
+          error: null,
+          hasResolved: true,
+          isLoading: false,
+          statusCounts: result.statusCounts ?? current.issues.statusCounts,
+          value: result.issues
+        }
+      }));
+      applyNodeState(
+        (current) => applyIssueManagerIssueListResultToNodeState(current, result)
+      );
+      flushPendingIssueSearchAnalytics(searchQuery, result.issues.length);
+    } catch (error) {
+      if (!retained || sequence !== issueListSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        issues: {
+          error: resolveIssueManagerErrorMessage(error, input.feature.i18n),
+          hasResolved: true,
+          isLoading: false,
+          statusCounts: current.issues.statusCounts,
+          value: []
+        }
+      }));
+    }
+  };
+  const clearIssueDetail = () => {
+    setSnapshot((current) => ({
+      ...current,
+      issueDetail: createAsyncCollectionState(
+        null
+      )
+    }));
+    syncIssueDraftFromCurrentDetail();
+  };
+  const clearTaskDetail = () => {
+    setSnapshot((current) => ({
+      ...current,
+      taskDetail: createAsyncCollectionState(
+        null
+      )
+    }));
+    syncTaskDraftFromCurrentDetail();
+  };
+  const loadIssueDetail = async () => {
+    const selectedIssueId = snapshot.nodeState.selectedIssueId;
+    issueDetailSequence += 1;
+    const sequence = issueDetailSequence;
+    if (!selectedIssueId) {
+      clearIssueDetail();
+      clearTaskDetail();
+      return;
+    }
+    setSnapshot((current) => ({
+      ...current,
+      issueDetail: {
+        ...current.issueDetail,
+        error: null,
+        isLoading: true
+      }
+    }));
+    try {
+      const result = await input.feature.backend.getIssueDetail({
+        issueId: selectedIssueId,
+        workspaceId: input.workspaceId
+      });
+      if (!retained || sequence !== issueDetailSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        issueDetail: {
+          error: null,
+          isLoading: false,
+          value: result
+        }
+      }));
+      syncIssueDraftFromCurrentDetail();
+      applyNodeState(
+        (current) => applyIssueManagerIssueDetailResultToNodeState(current, result)
+      );
+    } catch (error) {
+      if (!retained || sequence !== issueDetailSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        issueDetail: {
+          error: resolveIssueManagerErrorMessage(error, input.feature.i18n),
+          isLoading: false,
+          value: null
+        }
+      }));
+      syncIssueDraftFromCurrentDetail();
+    }
+  };
+  const loadTaskDetail = async () => {
+    const selectedIssueId = snapshot.nodeState.selectedIssueId;
+    const selectedTaskId = snapshot.nodeState.selectedTaskId;
+    taskDetailSequence += 1;
+    const sequence = taskDetailSequence;
+    if (!selectedIssueId || !selectedTaskId) {
+      clearTaskDetail();
+      return;
+    }
+    setSnapshot((current) => ({
+      ...current,
+      taskDetail: {
+        ...current.taskDetail,
+        error: null,
+        isLoading: true
+      }
+    }));
+    try {
+      const result = await input.feature.backend.getTaskDetail({
+        issueId: selectedIssueId,
+        taskId: selectedTaskId,
+        workspaceId: input.workspaceId
+      });
+      if (!retained || sequence !== taskDetailSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        taskDetail: {
+          error: null,
+          isLoading: false,
+          value: result
+        }
+      }));
+      syncTaskDraftFromCurrentDetail();
+    } catch (error) {
+      if (!retained || sequence !== taskDetailSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        taskDetail: {
+          error: resolveIssueManagerErrorMessage(error, input.feature.i18n),
+          isLoading: false,
+          value: null
+        }
+      }));
+      syncTaskDraftFromCurrentDetail();
+    }
+  };
+  const handleNodeStateTransition = (previous, next) => {
+    if (!retained) {
+      return;
+    }
+    if (previous.activeTopicId !== next.activeTopicId && next.activeTopicId) {
+      applyNodeState({
+        selectedIssueId: null,
+        selectedTaskId: null
+      });
+      void loadIssues();
+      return;
+    }
+    if (previous.issueStatusFilter !== next.issueStatusFilter && deferredIssueSearch === snapshot.nodeState.issueSearchQuery) {
+      void loadIssues();
+    }
+    if (previous.selectedIssueId !== next.selectedIssueId) {
+      void loadIssueDetail();
+      return;
+    }
+    if (previous.selectedTaskId !== next.selectedTaskId) {
+      void loadTaskDetail();
+    }
+  };
+  const retainIssueUpdates = () => {
+    if (unsubscribeIssueUpdates || !input.feature.eventSource) {
+      return;
+    }
+    unsubscribeIssueUpdates = input.feature.eventSource.subscribeToIssueUpdates(
+      input.workspaceId,
+      (event) => {
+        if (event.workspaceId.trim() !== input.workspaceId.trim()) {
+          return;
+        }
+        void loadTopics();
+        void loadIssueDetail();
+        void loadTaskDetail();
+      }
+    );
+    try {
+      const connectResult = input.feature.eventSource.connect?.();
+      if (connectResult) {
+        void connectResult.catch(() => {
+        });
+      }
+    } catch {
+    }
+  };
+  const releaseIssueUpdates = () => {
+    unsubscribeIssueUpdates?.();
+    unsubscribeIssueUpdates = null;
+  };
+  return {
+    getSnapshot() {
+      return snapshot;
+    },
+    refreshAll() {
+      if (!retained) {
+        return;
+      }
+      void loadTopics();
+      void loadIssueDetail();
+      void loadTaskDetail();
+    },
+    refreshDetails() {
+      if (!retained) {
+        return;
+      }
+      void loadIssueDetail();
+      void loadTaskDetail();
+    },
+    release() {
+      refCount = Math.max(0, refCount - 1);
+      if (refCount > 0) {
+        return;
+      }
+      retained = false;
+      issueListSequence += 1;
+      issueDetailSequence += 1;
+      taskDetailSequence += 1;
+      topicListSequence += 1;
+      releaseIssueUpdates();
+    },
+    reportIssueSearchUsage(query) {
+      const searchQuery = query.trim();
+      if (!searchQuery) {
+        return;
+      }
+      pendingIssueSearchAnalyticsQuery = searchQuery;
+      if (lastResolvedIssueSearchQuery === searchQuery && !snapshot.issues.isLoading) {
+        flushPendingIssueSearchAnalytics(
+          searchQuery,
+          snapshot.issues.value.length
+        );
+      }
+    },
+    retain() {
+      refCount += 1;
+      if (retained) {
+        return;
+      }
+      retained = true;
+      if (!hasReportedOpened) {
+        hasReportedOpened = true;
+        void Promise.resolve(
+          input.feature.analytics?.track({
+            name: "issue_manager.opened",
+            params: createIssueManagerOpenedParams(
+              input.openSource ?? "restore"
+            )
+          })
+        ).catch(() => void 0);
+      }
+      retainIssueUpdates();
+      void loadTopics();
+      void loadIssueDetail();
+      void loadTaskDetail();
+    },
+    setIsRunningTask(update) {
+      setSnapshot((current) => ({
+        ...current,
+        isRunningTask: resolveSetStateAction(update, current.isRunningTask)
+      }));
+    },
+    setIssueDraftInternal(update) {
+      setSnapshot((current) => ({
+        ...current,
+        issueDraft: resolveSetStateAction(update, current.issueDraft)
+      }));
+    },
+    setIssueEditorModeState(update) {
+      const nextMode = resolveSetStateAction(update, snapshot.issueEditorMode);
+      setSnapshot((current) => ({
+        ...current,
+        issueEditorMode: nextMode
+      }));
+      syncIssueDraftFromCurrentDetail();
+    },
+    setReferenceTarget(update) {
+      setSnapshot((current) => ({
+        ...current,
+        referenceTarget: resolveSetStateAction(update, current.referenceTarget)
+      }));
+    },
+    setNotification(update) {
+      setSnapshot((current) => ({
+        ...current,
+        notification: resolveSetStateAction(update, current.notification)
+      }));
+    },
+    setTaskDraftInternal(update) {
+      setSnapshot((current) => ({
+        ...current,
+        taskDraft: resolveSetStateAction(update, current.taskDraft)
+      }));
+    },
+    setTaskEditorModeState(update) {
+      const nextMode = resolveSetStateAction(update, snapshot.taskEditorMode);
+      setSnapshot((current) => ({
+        ...current,
+        taskEditorMode: nextMode
+      }));
+      syncTaskDraftFromCurrentDetail();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    syncInput(nextInput) {
+      onStateChange = nextInput.onStateChange;
+      if (deferredIssueSearch !== nextInput.deferredIssueSearch) {
+        deferredIssueSearch = nextInput.deferredIssueSearch;
+        if (retained) {
+          void loadIssues();
+        }
+      }
+      if (snapshot.nodeState.taskListCollapsed === true !== nextInput.taskListCollapsed) {
+        applyNodeState((current) => ({
+          ...current,
+          taskListCollapsed: nextInput.taskListCollapsed
+        }));
+      }
+    },
+    updateNodeState(updater) {
+      applyNodeState(updater);
+    },
+    store
+  };
+}
+function createAsyncCollectionState(value, options) {
+  return {
+    error: null,
+    ...options,
+    isLoading: false,
+    value
+  };
+}
+function resolveSetStateAction(update, current) {
+  return typeof update === "function" ? update(current) : update;
+}
+
+// src/services/internal/issueManagerControllerService.ts
+var DefaultIssueManagerControllerService = class {
+  createSession(input) {
+    return createIssueManagerControllerRuntime(input);
+  }
+};
+
+// src/services/createIssueManagerControllerService.ts
+function createIssueManagerControllerService() {
+  return new DefaultIssueManagerControllerService();
+}
+
+export {
+  createIssueManagerDate,
+  formatIssueManagerTimestamp,
+  formatIssueManagerDate,
+  resolveIssueManagerStatusLabel,
+  resolveIssueManagerPriorityLabel,
+  uniqueIssueManagerFileReferences,
+  parentDirectoryPath,
+  defaultTaskPriority,
+  toContextRefInput,
+  toIssueManagerWorkspaceFileLinkInput,
+  confirmIssueManagerMessage,
+  resolveIssueManagerErrorMessage,
+  resolveIssueManagerTopicDeleteErrorMessage,
+  createIssueManagerIssueDraftFromNodeState,
+  createIssueManagerTaskDraftFromNodeState,
+  applyIssueManagerIssueSelection,
+  applyIssueManagerTaskSelection,
+  applyIssueManagerIssueDeleted,
+  applyIssueManagerTaskDeleted,
+  applyIssueManagerSelectedAgentProvider,
+  applyIssueManagerSelectedExecutionDirectory,
+  applyIssueManagerIssueEditorModeToNodeState,
+  applyIssueManagerTaskEditorModeToNodeState,
+  applyIssueManagerIssueSaved,
+  applyIssueManagerTaskSaved,
+  persistIssueManagerIssueDraftContent,
+  persistIssueManagerTaskDraftContent,
+  createIssueManagerControllerService
+};
+//# sourceMappingURL=chunk-4B2P64PY.js.map