@nextop-os/workspace-issue-manager 0.0.18 → 0.0.20

package/dist/chunk-ZWDF5XA7.js

@@ -0,0 +1,735 @@
+import {
+  normalizeIssueManagerContent,
+  normalizeIssueManagerNodeState
+} from "./chunk-V75TAM27.js";
+
+// src/services/internal/model.ts
+import { formatNextopShortDateTime } from "@nextop-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 "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 tasks[0]?.taskId ?? 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;
+}
+
+// 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 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 persistIssueManagerIssueDraftTitle(current, editorMode, title) {
+  if (editorMode !== "create") {
+    return current;
+  }
+  return {
+    ...current,
+    issueDraftTitle: title
+  };
+}
+function persistIssueManagerTaskDraftContent(current, editorMode, content) {
+  if (editorMode !== "create") {
+    return current;
+  }
+  return {
+    ...current,
+    taskDraftContent: content
+  };
+}
+function persistIssueManagerTaskDraftTitle(current, editorMode, title) {
+  if (editorMode !== "create") {
+    return current;
+  }
+  return {
+    ...current,
+    taskDraftTitle: title
+  };
+}
+
+// src/services/internal/controllerRuntime.ts
+function createIssueManagerControllerRuntime(input) {
+  const normalizedNodeState = normalizeIssueManagerNodeState(input.state);
+  const listeners = /* @__PURE__ */ new Set();
+  let deferredIssueSearch = normalizedNodeState.issueSearchQuery;
+  let issueDetailSequence = 0;
+  let issueListSequence = 0;
+  let onStateChange;
+  let refCount = 0;
+  let retained = false;
+  let taskDetailSequence = 0;
+  let snapshot = {
+    issueDetail: createAsyncCollectionState(
+      null
+    ),
+    issueDraft: createIssueManagerIssueDraftFromNodeState(normalizedNodeState),
+    issueEditorMode: "read",
+    issues: createAsyncCollectionState([]),
+    isRunningTask: false,
+    nodeState: normalizedNodeState,
+    notification: null,
+    referenceTarget: null,
+    taskDetail: createAsyncCollectionState(null),
+    taskDraft: createIssueManagerTaskDraftFromNodeState(normalizedNodeState),
+    taskEditorMode: "read"
+  };
+  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 loadIssues = async () => {
+    const sequence = ++issueListSequence;
+    setSnapshot((current) => ({
+      ...current,
+      issues: {
+        ...current.issues,
+        error: null,
+        isLoading: true
+      }
+    }));
+    try {
+      const result = await input.feature.backend.listIssues({
+        searchQuery: deferredIssueSearch || void 0,
+        statusFilter: snapshot.nodeState.issueStatusFilter,
+        workspaceId: input.workspaceId
+      });
+      if (!retained || sequence !== issueListSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        issues: {
+          error: null,
+          isLoading: false,
+          value: result.issues
+        }
+      }));
+      applyNodeState(
+        (current) => applyIssueManagerIssueListResultToNodeState(current, result)
+      );
+    } catch (error) {
+      if (!retained || sequence !== issueListSequence) {
+        return;
+      }
+      setSnapshot((current) => ({
+        ...current,
+        issues: {
+          error: resolveIssueManagerErrorMessage(error, input.feature.i18n),
+          isLoading: false,
+          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.issueStatusFilter !== next.issueStatusFilter && deferredIssueSearch === snapshot.nodeState.issueSearchQuery) {
+      void loadIssues();
+    }
+    if (previous.selectedIssueId !== next.selectedIssueId) {
+      void loadIssueDetail();
+      return;
+    }
+    if (previous.selectedTaskId !== next.selectedTaskId) {
+      void loadTaskDetail();
+    }
+  };
+  return {
+    getSnapshot() {
+      return snapshot;
+    },
+    refreshAll() {
+      if (!retained) {
+        return;
+      }
+      void loadIssues();
+      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;
+    },
+    retain() {
+      refCount += 1;
+      if (retained) {
+        return;
+      }
+      retained = true;
+      void loadIssues();
+      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) {
+  return {
+    error: null,
+    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,
+  createIssueManagerIssueDraftFromNodeState,
+  createIssueManagerTaskDraftFromNodeState,
+  applyIssueManagerIssueSelection,
+  applyIssueManagerTaskSelection,
+  applyIssueManagerIssueDeleted,
+  applyIssueManagerTaskDeleted,
+  applyIssueManagerSelectedAgentProvider,
+  applyIssueManagerIssueEditorModeToNodeState,
+  applyIssueManagerTaskEditorModeToNodeState,
+  applyIssueManagerIssueSaved,
+  applyIssueManagerTaskSaved,
+  persistIssueManagerIssueDraftContent,
+  persistIssueManagerIssueDraftTitle,
+  persistIssueManagerTaskDraftContent,
+  persistIssueManagerTaskDraftTitle,
+  createIssueManagerControllerService
+};
+//# sourceMappingURL=chunk-ZWDF5XA7.js.map