@mndrk/agx 2.3.3 → 2.4.2

package/cloud-runtime/standalone/apps/local/state/trackerBoardFilters.ts

@@ -0,0 +1,112 @@
+const TRACKER_BOARD_FILTERS_STORAGE_PREFIX = "agx-tracker:boardFilters";
+
+export interface TrackerBoardFilters {
+  search: string;
+  assigneeIds: string[];
+  statusCategories: string[];
+  groupIds: string[];
+  sortBy: "activity" | "identifier" | "status" | "created";
+  sortDir: "asc" | "desc";
+  hasActivity: boolean;
+}
+
+const DEFAULT_TRACKER_BOARD_FILTERS: TrackerBoardFilters = {
+  search: "",
+  assigneeIds: [],
+  statusCategories: [],
+  groupIds: [],
+  sortBy: "activity",
+  sortDir: "desc",
+  hasActivity: false,
+};
+
+function isStorageAvailable(): boolean {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+
+function normalizeStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return Array.from(
+    new Set(
+      value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter(Boolean)
+    )
+  );
+}
+
+export function getTrackerBoardFiltersStorageKey(
+  trackerType: string,
+  projectSlug?: string | null
+): string {
+  const normalizedProjectSlug = String(projectSlug ?? "").trim().toLowerCase();
+  const prefix = `${TRACKER_BOARD_FILTERS_STORAGE_PREFIX}:${trackerType}`;
+  return normalizedProjectSlug
+    ? `${prefix}:${normalizedProjectSlug}`
+    : `${prefix}:global`;
+}
+
+export function loadTrackerBoardFilters(
+  trackerType: string,
+  projectSlug?: string | null
+): TrackerBoardFilters {
+  if (!isStorageAvailable()) {
+    return { ...DEFAULT_TRACKER_BOARD_FILTERS };
+  }
+
+  const raw = window.localStorage.getItem(getTrackerBoardFiltersStorageKey(trackerType, projectSlug));
+  if (!raw) {
+    return { ...DEFAULT_TRACKER_BOARD_FILTERS };
+  }
+
+  try {
+    const parsed = JSON.parse(raw) as Partial<TrackerBoardFilters>;
+    return {
+      search: typeof parsed.search === "string" ? parsed.search : DEFAULT_TRACKER_BOARD_FILTERS.search,
+      assigneeIds: normalizeStringArray(parsed.assigneeIds),
+      statusCategories: normalizeStringArray(parsed.statusCategories),
+      groupIds: normalizeStringArray(parsed.groupIds),
+      sortBy: ["activity", "identifier", "status", "created"].includes(parsed.sortBy as string)
+        ? (parsed.sortBy as TrackerBoardFilters["sortBy"])
+        : DEFAULT_TRACKER_BOARD_FILTERS.sortBy,
+      sortDir: ["asc", "desc"].includes(parsed.sortDir as string)
+        ? (parsed.sortDir as TrackerBoardFilters["sortDir"])
+        : DEFAULT_TRACKER_BOARD_FILTERS.sortDir,
+      hasActivity: typeof parsed.hasActivity === "boolean"
+        ? parsed.hasActivity
+        : DEFAULT_TRACKER_BOARD_FILTERS.hasActivity,
+    };
+  } catch {
+    return { ...DEFAULT_TRACKER_BOARD_FILTERS };
+  }
+}
+
+export function persistTrackerBoardFilters(
+  trackerType: string,
+  projectSlug: string | null | undefined,
+  filters: TrackerBoardFilters
+): void {
+  if (!isStorageAvailable()) {
+    return;
+  }
+
+  try {
+    window.localStorage.setItem(
+      getTrackerBoardFiltersStorageKey(trackerType, projectSlug),
+      JSON.stringify({
+        search: filters.search,
+        assigneeIds: normalizeStringArray(filters.assigneeIds),
+        statusCategories: normalizeStringArray(filters.statusCategories),
+        groupIds: normalizeStringArray(filters.groupIds),
+        sortBy: filters.sortBy || "activity",
+        sortDir: filters.sortDir || "desc",
+        hasActivity: !!filters.hasActivity,
+      })
+    );
+  } catch {
+    // ignore storage errors
+  }
+}

package/cloud-runtime/standalone/apps/local/state/{linearBoardPins.ts → trackerBoardPins.ts}

@@ -1,20 +1,24 @@
-const LINEAR_BOARD_PINS_STORAGE_PREFIX = "agx-linear:pinnedIssues";
+const TRACKER_BOARD_PINS_STORAGE_PREFIX = "agx-tracker:pinnedItems";
 
 function isStorageAvailable(): boolean {
   return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
 }
 
-function getStorageKey(projectSlug?: string | null): string {
+function getStorageKey(trackerType: string, projectSlug?: string | null): string {
   const normalized = String(projectSlug ?? "").trim().toLowerCase();
+  const prefix = `${TRACKER_BOARD_PINS_STORAGE_PREFIX}:${trackerType}`;
   return normalized
-    ? `${LINEAR_BOARD_PINS_STORAGE_PREFIX}:${normalized}`
-    : `${LINEAR_BOARD_PINS_STORAGE_PREFIX}:global`;
+    ? `${prefix}:${normalized}`
+    : `${prefix}:global`;
 }
 
-export function loadPinnedIssueIds(projectSlug?: string | null): Set<string> {
+export function loadPinnedTrackerItemIds(
+  trackerType: string,
+  projectSlug?: string | null
+): Set<string> {
   if (!isStorageAvailable()) return new Set();
 
-  const raw = window.localStorage.getItem(getStorageKey(projectSlug));
+  const raw = window.localStorage.getItem(getStorageKey(trackerType, projectSlug));
   if (!raw) return new Set();
 
   try {
@@ -28,7 +32,8 @@ export function loadPinnedIssueIds(projectSlug?: string | null): Set<string> {
   }
 }
 
-export function persistPinnedIssueIds(
+export function persistPinnedTrackerItemIds(
+  trackerType: string,
   projectSlug: string | null | undefined,
   ids: Set<string>
 ): void {
@@ -36,10 +41,10 @@ export function persistPinnedIssueIds(
 
   try {
     window.localStorage.setItem(
-      getStorageKey(projectSlug),
+      getStorageKey(trackerType, projectSlug),
       JSON.stringify([...ids])
     );
   } catch {
     // ignore storage errors
   }
-}
+}

package/cloud-runtime/standalone/apps/local/state/{linearRunScripts.ts → trackerRunScripts.ts}

@@ -1,6 +1,6 @@
-const LINEAR_RUN_SCRIPTS_STORAGE_PREFIX = "agx-linear:runScripts";
+const TRACKER_RUN_SCRIPTS_STORAGE_PREFIX = "agx-tracker:runScripts";
 
-export interface LinearRunScript {
+export interface TrackerRunScript {
   id: string;
   name: string;
   prompt: string;
@@ -8,12 +8,12 @@ export interface LinearRunScript {
   updatedAt: string;
 }
 
-export interface LinearRunScriptsState {
+export interface TrackerRunScriptsState {
   activeScriptId: string | null;
-  scripts: LinearRunScript[];
+  scripts: TrackerRunScript[];
 }
 
-const DEFAULT_LINEAR_RUN_SCRIPTS_STATE: LinearRunScriptsState = {
+const DEFAULT_TRACKER_RUN_SCRIPTS_STATE: TrackerRunScriptsState = {
   activeScriptId: null,
   scripts: [],
 };
@@ -26,12 +26,12 @@ function normalizeProjectSlug(projectSlug?: string | null): string {
   return String(projectSlug ?? "").trim().toLowerCase();
 }
 
-function normalizeScript(input: unknown): LinearRunScript | null {
+function normalizeScript(input: unknown): TrackerRunScript | null {
   if (!input || typeof input !== "object") {
     return null;
   }
 
-  const candidate = input as Partial<LinearRunScript>;
+  const candidate = input as Partial<TrackerRunScript>;
   const id = typeof candidate.id === "string" ? candidate.id.trim() : "";
   const name = typeof candidate.name === "string" ? candidate.name.trim() : "";
   const prompt = typeof candidate.prompt === "string" ? candidate.prompt.trim() : "";
@@ -57,21 +57,21 @@ function normalizeScript(input: unknown): LinearRunScript | null {
   };
 }
 
-function sortScripts(scripts: LinearRunScript[]): LinearRunScript[] {
+function sortScripts(scripts: TrackerRunScript[]): TrackerRunScript[] {
   return [...scripts].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
 }
 
-function normalizeState(value: unknown): LinearRunScriptsState {
+function normalizeState(value: unknown): TrackerRunScriptsState {
   if (!value || typeof value !== "object") {
-    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+    return { ...DEFAULT_TRACKER_RUN_SCRIPTS_STATE };
   }
 
-  const candidate = value as Partial<LinearRunScriptsState>;
+  const candidate = value as Partial<TrackerRunScriptsState>;
   const scripts = Array.isArray(candidate.scripts)
     ? sortScripts(
         candidate.scripts
           .map((script) => normalizeScript(script))
-          .filter((script): script is LinearRunScript => Boolean(script))
+          .filter((script): script is TrackerRunScript => Boolean(script))
       )
     : [];
   const activeScriptId =
@@ -88,33 +88,41 @@ function normalizeState(value: unknown): LinearRunScriptsState {
   };
 }
 
-export function getLinearRunScriptsStorageKey(projectSlug?: string | null): string {
+export function getTrackerRunScriptsStorageKey(
+  trackerType: string,
+  projectSlug?: string | null
+): string {
   const normalizedProjectSlug = normalizeProjectSlug(projectSlug);
+  const prefix = `${TRACKER_RUN_SCRIPTS_STORAGE_PREFIX}:${trackerType}`;
   return normalizedProjectSlug
-    ? `${LINEAR_RUN_SCRIPTS_STORAGE_PREFIX}:${normalizedProjectSlug}`
-    : `${LINEAR_RUN_SCRIPTS_STORAGE_PREFIX}:global`;
+    ? `${prefix}:${normalizedProjectSlug}`
+    : `${prefix}:global`;
 }
 
-export function loadLinearRunScripts(projectSlug?: string | null): LinearRunScriptsState {
+export function loadTrackerRunScripts(
+  trackerType: string,
+  projectSlug?: string | null
+): TrackerRunScriptsState {
   if (!isStorageAvailable()) {
-    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+    return { ...DEFAULT_TRACKER_RUN_SCRIPTS_STATE };
   }
 
-  const raw = window.localStorage.getItem(getLinearRunScriptsStorageKey(projectSlug));
+  const raw = window.localStorage.getItem(getTrackerRunScriptsStorageKey(trackerType, projectSlug));
   if (!raw) {
-    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+    return { ...DEFAULT_TRACKER_RUN_SCRIPTS_STATE };
   }
 
   try {
     return normalizeState(JSON.parse(raw));
   } catch {
-    return { ...DEFAULT_LINEAR_RUN_SCRIPTS_STATE };
+    return { ...DEFAULT_TRACKER_RUN_SCRIPTS_STATE };
   }
 }
 
-export function persistLinearRunScripts(
+export function persistTrackerRunScripts(
+  trackerType: string,
   projectSlug: string | null | undefined,
-  state: LinearRunScriptsState
+  state: TrackerRunScriptsState
 ): void {
   if (!isStorageAvailable()) {
     return;
@@ -123,10 +131,10 @@ export function persistLinearRunScripts(
   try {
     const normalized = normalizeState(state);
     window.localStorage.setItem(
-      getLinearRunScriptsStorageKey(projectSlug),
+      getTrackerRunScriptsStorageKey(trackerType, projectSlug),
       JSON.stringify(normalized)
     );
   } catch {
     // ignore storage errors
   }
-}
+}