@alpaca-editor/core 1.0.4056 → 1.0.4059

package/src/editor/menubar/PageSelector.tsx

@@ -11,7 +11,7 @@ import { ResultItem } from "../ui/ItemSearch";
 import { ScrollingContentTree } from "../ScrollingContentTree";
 import { ItemTreeNodeData } from "../services/contentService";
 import { SimpleIconButton } from "../ui/SimpleIconButton";
-import { executeSearch } from "../services/aiService";
+import { executeSearch } from "../services/searchService";
 import { ItemList } from "../ui/ItemList";
 import { DotsVerticalIcon } from "@radix-ui/react-icons";
 import {

package/src/editor/reviews/Comment.tsx

@@ -6,6 +6,7 @@ import {
   deleteComment,
   resolveComment,
   unresolveComment,
+  getAvailableCommentTags,
 } from "../services/reviewsService";
 import { Button } from "../../components/ui/button";
 import { formatDate } from "../utils";
@@ -19,7 +20,13 @@ import { ProgressSpinner } from "primereact/progressspinner";
 import { useDebouncedCallback } from "use-debounce";
 import { ActionButton } from "../../components/ActionButton";
 
-export function Comment({ comment }: { comment: CommentType }) {
+export function Comment({
+  comment,
+  availableTags = [],
+}: {
+  comment: CommentType;
+  availableTags?: { label: string; color: string }[];
+}) {
   const editContext = useEditContext();
   const [commentText, setCommentText] = useState(comment.text);
   const [isEditing, setIsEditing] = useState(false);
@@ -42,6 +49,37 @@ export function Comment({ comment }: { comment: CommentType }) {
     }
   }, [isSelected]);
 
+  // availableTags now provided by parent for efficiency
+
+  const renderTags = () => {
+    const tagLabels = (comment.tags || "")
+      .split(",")
+      .map((t) => t.trim())
+      .filter(Boolean);
+    if (tagLabels.length === 0) return null;
+
+    const colorMap = new Map(availableTags.map((t) => [t.label, t.color]));
+    return (
+      <div className="mt-2 flex flex-wrap gap-2">
+        {tagLabels.map((label) => {
+          const color = colorMap.get(label);
+          return (
+            <span
+              key={label}
+              className="text-2xs rounded border px-2 py-0.5"
+              style={{
+                borderColor: color || undefined,
+                backgroundColor: color ? color + "22" : undefined,
+              }}
+            >
+              {label}
+            </span>
+          );
+        })}
+      </div>
+    );
+  };
+
   const renderContextInfo = () => {
     const showItemName =
       comment.itemId && comment.mainItemId !== comment.itemId;
@@ -239,6 +277,7 @@ export function Comment({ comment }: { comment: CommentType }) {
       <div className="text-sm whitespace-pre-wrap text-gray-700">
         {comment.text}
       </div>
+      {renderTags()}
       {renderContextInfo()}
     </div>
   ) : (

package/src/editor/reviews/CommentDisplayPopover.tsx

@@ -298,7 +298,7 @@ export function CommentDisplayPopover({
           )}
 
           {/* Actions */}
-          {!isEditing && !deleteConfirm && (
+          {!isEditing && !deleteConfirm && !editContext?.configuration?.forceFullscreen && (
             <div className="border-t pt-3">
               <Button
                 variant="outline"

package/src/editor/reviews/CommentPopover.tsx

@@ -5,7 +5,10 @@ import { useEffect, useLayoutEffect, useState } from "react";
 import uuid from "react-uuid";
 import { Send, MessageCirclePlus } from "lucide-react";
 import { useEditContext, EditContextType } from "../client/editContext";
-import { createOrUpdateComment } from "../services/reviewsService";
+import {
+  createOrUpdateComment,
+  getAvailableCommentTags,
+} from "../services/reviewsService";
 import {
   Popover,
   PopoverContent,
@@ -31,6 +34,10 @@ export function CommentPopover({
   const [text, setText] = useState("");
   const textareaRef = React.useRef<HTMLTextAreaElement | null>(null);
   const [saving, setSaving] = useState(false);
+  const [availableTags, setAvailableTags] = useState<
+    { label: string; color: string }[]
+  >([]);
+  const [selectedTags, setSelectedTags] = useState<string[]>([]);
   const contextFromHook = useEditContext();
   const editContext = externalEditContext || contextFromHook;
 
@@ -38,6 +45,24 @@ export function CommentPopover({
     if (position) setIsOpen(true);
   }, [position?.x, position?.y]);
 
+  useEffect(() => {
+    let cancelled = false;
+    const loadTags = async () => {
+      try {
+        const descriptor = editContext?.contentEditorItem?.descriptor;
+        if (!descriptor) return;
+        const tags = await getAvailableCommentTags(descriptor);
+        if (!cancelled) setAvailableTags(tags || []);
+      } catch {
+        if (!cancelled) setAvailableTags([]);
+      }
+    };
+    loadTags();
+    return () => {
+      cancelled = true;
+    };
+  }, [editContext?.contentEditorItem?.descriptor?.id]);
+
   const handleSubmit = async () => {
     if (!editContext || !text.trim() || saving) return;
     const descriptor = editContext.contentEditorItem?.descriptor;
@@ -90,6 +115,8 @@ export function CommentPopover({
         authorDisplayName: editContext.user?.displayName,
         date: new Date().toISOString(),
         text: text.trim(),
+        // send as comma-separated labels (server can parse if supported)
+        tags: selectedTags.join(","),
       } as any;
 
       editContext.setComments([newComment, ...editContext.comments]);
@@ -114,6 +141,7 @@ export function CommentPopover({
       setSaving(false);
       setIsOpen(false);
       setText("");
+      setSelectedTags([]);
       onClose?.();
     }
   };
@@ -200,6 +228,41 @@ export function CommentPopover({
             rows={3}
             autoFocus
           />
+          {availableTags.length > 0 && (
+            <div className="space-y-2">
+              <div className="text-muted-foreground text-xs">Tags</div>
+              <div className="flex flex-wrap gap-2">
+                {availableTags.map((t) => {
+                  const isSelected = selectedTags.includes(t.label);
+                  return (
+                    <Button
+                      key={t.label}
+                      type="button"
+                      size="sm"
+                      asChild={false}
+                      variant={isSelected ? "secondary" : "outline"}
+                      className="h-6 px-2 text-xs"
+                      onClick={() => {
+                        setSelectedTags((prev) =>
+                          prev.includes(t.label)
+                            ? prev.filter((l) => l !== t.label)
+                            : [...prev, t.label],
+                        );
+                      }}
+                      style={{
+                        borderColor: isSelected ? t.color : undefined,
+                        backgroundColor: isSelected
+                          ? t.color + "22"
+                          : undefined,
+                      }}
+                    >
+                      {t.label}
+                    </Button>
+                  );
+                })}
+              </div>
+            </div>
+          )}
           <div className="flex justify-end gap-2">
             <Button
               variant="outline"

package/src/editor/reviews/Comments.tsx

@@ -21,6 +21,9 @@ export function Comments() {
   const [feedbackItems, setFeedbackItems] = useState<FeedbackItem[]>([]);
   const [hideAppliedSuggestions, setHideAppliedSuggestions] =
     useState<boolean>(true);
+  const [availableTags, setAvailableTags] = useState<
+    { label: string; color: string }[]
+  >([]);
 
   useEffect(() => {
     // Retrieve your list of comments (and ensure there's an array of suggested edits,
@@ -45,6 +48,31 @@ export function Comments() {
     setFeedbackItems(combined);
   }, [editContext, hideAppliedSuggestions]);
 
+  // Load available tags once per context for color mapping in child comments
+  useEffect(() => {
+    let cancelled = false;
+    const loadTags = async () => {
+      try {
+        const descriptor = editContext?.contentEditorItem?.descriptor;
+        if (!descriptor) {
+          if (!cancelled) setAvailableTags([]);
+          return;
+        }
+        const { getAvailableCommentTags } = await import(
+          "../services/reviewsService"
+        );
+        const tags = await getAvailableCommentTags(descriptor);
+        if (!cancelled) setAvailableTags(tags || []);
+      } catch {
+        if (!cancelled) setAvailableTags([]);
+      }
+    };
+    loadTags();
+    return () => {
+      cancelled = true;
+    };
+  }, [editContext?.contentEditorItem?.descriptor?.id]);
+
   return (
     <div className="flex h-full flex-col">
       <div className="border-gray-3 flex-1 overflow-auto border-b">
@@ -60,7 +88,11 @@ export function Comments() {
               );
             }
             return (
-              <CommentComponent key={item.id} comment={item as CommentType} />
+              <CommentComponent
+                key={item.id}
+                comment={item as CommentType}
+                availableTags={availableTags}
+              />
             );
           })}
         </div>

package/src/editor/reviews/SuggestionDisplayPopover.tsx

@@ -381,7 +381,7 @@ export function SuggestionDisplayPopover({
           )}
 
           {/* Actions */}
-          {!deleteConfirm && (
+          {!deleteConfirm && !editContext?.configuration?.forceFullscreen && (
             <div className="border-t pt-3">
               <Button
                 variant="outline"

package/src/editor/services/aiService.ts

@@ -289,45 +289,7 @@ export async function executePrompt(
   return result;
 }
 
-export async function executeSearch({
-  query,
-  editContext,
-  maxResults = 10,
-  index,
-  rootItemIds,
-  skipValidation = false,
-}: {
-  query: string;
-  editContext: EditContextType;
-  maxResults: number;
-  index: string;
-  rootItemIds?: string[];
-  skipValidation?: boolean;
-}): Promise<ExecutionResult<unknown>> {
-  const response = await fetch("/alpaca/editor/ai/search", {
-    method: "POST",
-    body: JSON.stringify({
-      contextItem: {
-        id: editContext.currentItemDescriptor?.id,
-        language: "en",
-        version: 0,
-      },
-      query,
-      index,
-      maxResults,
-      rootItemIds,
-      skipValidation,
-    }),
-    credentials: "include",
-    headers: {
-      "Content-Type": "application/json",
-    },
-  });
-
-  if (!response.ok) return { type: "error", response };
-
-  return { type: "success", response, data: await response.json() };
-}
+// moved to searchService.ts
 
 export async function generateImage(
   options: FieldDescriptor & {

package/src/editor/services/indexService.ts

@@ -1,24 +1,58 @@
-import { IndexStatus } from "../../types";
+import {
+  IndexStatus,
+  StagingStatus,
+  CollectAndUploadResult,
+  SubmitStagedResult,
+  ImportStatus,
+} from "../../types";
 import { get, post } from "./serviceHelper";
 
-export async function getIndexStatus(index: string) {
-  var result = await get<IndexStatus>("/alpaca/headless/editor/index/status?name=" + index);
+export async function getIndexStatus() {
+  var result = await get<IndexStatus>("/alpaca/editor/index/status");
   return result.data;
 }
 
-export async function setupIndex(index: string) {
-  await post("/alpaca/headless/editor/index/setup?name=" + index, {});
+export async function rebuildIndex() {
+  await post("/alpaca/editor/index/rebuild", {});
 }
 
-export async function setupRebuildJob(index: string) {
-  await post("/alpaca/headless/editor/index/setuprebuildjob?name=" + index, {});
+export async function cleanupBatches() {
+  await post("/alpaca/editor/index/cleanup", {});
 }
 
-export async function rebuildIndex(index: string) {
-  await post("/alpaca/headless/editor/index/rebuild?name=" + index, {});
+export async function populateCentroids(k: number) {
+  await post(
+    `/alpaca/editor/index/populatecentroids?k=${encodeURIComponent(k)}` as any,
+    {},
+  );
 }
 
-export async function getIndexes(): Promise<string[]> {
-  var result = await get<string[]>("/alpaca/headless/editor/index/list");
-  return result.data || [];
+export async function processCompletedBatches() {
+  await post("/alpaca/editor/index/processcompletedbatches", {});
+}
+
+export async function collectAndUpload() {
+  const result = await post<CollectAndUploadResult>(
+    "/alpaca/editor/index/collectandupload",
+    {},
+  );
+  return result.data as CollectAndUploadResult;
+}
+
+export async function submitStaged() {
+  const result = await post<SubmitStagedResult>(
+    "/alpaca/editor/index/submitstaged",
+    {},
+  );
+  return result.data as SubmitStagedResult;
+}
+
+export async function getStagingStatus() {
+  const result = await get<StagingStatus>("/alpaca/editor/index/stagingstatus");
+  return result.data as StagingStatus;
+}
+
+export async function getImportStatus() {
+  const result = await get<ImportStatus>("/alpaca/editor/index/importstatus");
+  return result.data as ImportStatus;
 }

package/src/editor/services/reviewsService.ts

@@ -1,5 +1,5 @@
 import { get, post } from "./serviceHelper";
-import { Comment, Review, Reviewer } from "../../types";
+import { Comment, Review, Reviewer, CommentTag } from "../../types";
 import { ItemDescriptor } from "../pageModel";
 
 export function createOrUpdateComment(comment: Comment) {
@@ -51,3 +51,36 @@ export function approveReview(itemDescriptor: ItemDescriptor) {
 export function rejectReview(itemDescriptor: ItemDescriptor) {
   return post(`/alpaca/editor/reviews/reject`, itemDescriptor);
 }
+
+// New API endpoints for comment related items
+export function getCommentsByRelatedItem(itemId: string) {
+  return get<Comment[]>(
+    `/alpaca/editor/comments/getCommentsByRelatedItem?itemId=${itemId}`,
+  );
+}
+
+export function addRelatedItemToComment(commentId: string, itemId: string) {
+  return post(
+    `/alpaca/editor/comments/addRelatedItem?commentId=${commentId}&itemId=${itemId}`,
+    {},
+  );
+}
+
+export function removeRelatedItemFromComment(
+  commentId: string,
+  itemId: string,
+) {
+  return post(
+    `/alpaca/editor/comments/removeRelatedItem?commentId=${commentId}&itemId=${itemId}`,
+    {},
+  );
+}
+
+// Tags
+export async function getAvailableCommentTags(descriptor: ItemDescriptor) {
+  const result = await post<CommentTag[]>(
+    `/alpaca/editor/comments/getAvailableTags`,
+    descriptor,
+  );
+  return (result.data || []) as CommentTag[];
+}

package/src/editor/services/searchService.ts

@@ -0,0 +1,45 @@
+import { EditContextType } from "../client/editContext";
+
+export type ExecutionResult<T> =
+  | { type: "success"; response: Response; data: T }
+  | { type: "error"; response: Response };
+
+export async function executeSearch({
+  query,
+  editContext,
+  maxResults = 10,
+  index,
+  rootItemIds,
+  skipValidation = false,
+}: {
+  query: string;
+  editContext: EditContextType;
+  maxResults: number;
+  index: string;
+  rootItemIds?: string[];
+  skipValidation?: boolean;
+}): Promise<ExecutionResult<unknown>> {
+  const response = await fetch("/alpaca/editor/index/search", {
+    method: "POST",
+    body: JSON.stringify({
+      contextItem: {
+        id: editContext.currentItemDescriptor?.id,
+        language: "en",
+        version: 0,
+      },
+      query,
+      index,
+      maxResults,
+      rootItemIds,
+      skipValidation,
+    }),
+    credentials: "include",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!response.ok) return { type: "error", response };
+
+  return { type: "success", response, data: await response.json() };
+}

package/src/editor/ui/ItemSearch.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from "react";
 import { useEditContext } from "../client/editContext";
-import { executeSearch } from "../services/aiService";
+import { executeSearch } from "../services/searchService";
 import { toast } from "sonner";
 import { useDebouncedCallback } from "use-debounce";
 import { ProgressSpinner } from "primereact/progressspinner";

package/src/editor/ui/Spinner.tsx

@@ -1,11 +1,18 @@
+import { cn } from "../../lib/utils";
+
 export function Spinner({
   size = "4xl",
+  className,
 }: {
   size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl";
+  className?: string;
 }) {
   return (
     <i
-      className={`pi pi-spin pi-spinner text-${size} text-theme-secondary/40`}
+      className={cn(
+        `pi pi-spin pi-spinner text-${size} text-theme-secondary/40`,
+        className,
+      )}
     ></i>
   );
 }

package/src/editor/utils/keyboardNavigation.ts

@@ -50,7 +50,9 @@ export function useKeyboardNavigation(deps: KeyboardNavigationDependencies) {
       }
       if (event.ctrlKey && event.key === "F11") {
         event.preventDefault();
-        pageViewContext.setFullscreen(false);
+        if (!configuration.forceFullscreen) {
+          pageViewContext.setFullscreen(false);
+        }
       }
 
       // History Navigation (Alt + Arrow keys, Alt + Shift + Arrow keys for favorites only)

package/src/page-wizard/steps/ImagesStep.tsx

@@ -3,7 +3,8 @@ import { useEffect, useState } from "react";
 import { ScrollingContentTree } from "../../editor/ScrollingContentTree";
 import { ItemTreeNodeData } from "../../editor/services/contentService";
 import { useEditContext } from "../../editor/client/editContext";
-import { executePrompt, executeSearch } from "../../editor/services/aiService";
+import { executePrompt } from "../../editor/services/aiService";
+import { executeSearch } from "../../editor/services/searchService";
 import { createWizardAiContext } from "../service";
 import { ActionButton } from "../../components/ActionButton";
 import { classNames } from "primereact/utils";

package/src/revision.ts

@@ -1,2 +1,2 @@
-export const version = "1.0.4056";
-export const buildDate = "2025-08-21 12:00:29";
+export const version = "1.0.4059";
+export const buildDate = "2025-08-22 09:58:06";

package/src/types.ts

@@ -255,26 +255,51 @@ export type LanguagesAndVersions = {
 };
 
 export type IndexStatus = {
-  name: string;
-  exists: boolean;
-
-  errors: Error[];
-  hasRebuildJob: boolean;
-  settingsItemId?: string;
-  rebuildJobItemId?: string;
-  serviceUrl?: string;
-  lastRebuildStartDateTime?: Date;
-  languages: {
-    [language: string]: {
-      lastUpdated: Date;
-      numberOfItems: number;
-      status: string;
-    };
-  };
-  canRebuild: boolean;
-  isRunning: boolean;
-  rebuildCount: number;
-  rebuildTokensCount: number;
+  numberOfIndexedItems: number;
+  rebuilding: boolean;
+  batches: EmbeddingBatch[];
+  latestEmbeddedItems?: LatestEmbeddedItem[];
+};
+
+export type EmbeddingBatch = {
+  id: string;
+  status: string;
+  numberOfItems: number;
+  created: string;
+  errorMessage?: string;
+  firstErrors?: string[];
+  errorCount?: number;
+};
+
+export type LatestEmbeddedItem = {
+  itemId: string;
+  name?: string;
+  path?: string;
+  created: string;
+};
+
+export type StagingStatus = {
+  fileCount: number;
+  fileIds: string[];
+  estimatedInputTokens: number;
+  estimatedCost: number;
+};
+
+export type CollectAndUploadResult = {
+  uploadedFileIds: string[];
+  estimatedInputTokens: number;
+  estimatedCost: number;
+};
+
+export type SubmitStagedResult = {
+  submittedBatchIds: string[];
+  submittedCount: number;
+};
+
+export type ImportStatus = {
+  isImporting: boolean;
+  status: string;
+  startedAt?: string;
 };
 
 export type Error = {
@@ -282,6 +307,15 @@ export type Error = {
   details: string;
 };
 
+export type CommentRelatedItem = {
+  itemId: string;
+  created: string;
+  createdBy: string;
+  itemName?: string;
+  itemPath?: string;
+  templateName?: string;
+};
+
 export type Comment = {
   id: string;
   isNew: boolean;
@@ -303,6 +337,18 @@ export type Comment = {
   resolvedBy?: string;
   resolvedDate?: string;
   position: number;
+
+  // Legacy field - kept for backward compatibility during migration
+  /** @deprecated Use relatedItems instead. This field will be removed in a future version. */
+  tags?: string;
+
+  // New relational structure for item references
+  relatedItems?: CommentRelatedItem[];
+};
+
+export type CommentTag = {
+  label: string;
+  color: string;
 };
 
 export type Reviewer = {

package/dist/editor/control-center/IndexSettings.d.ts

@@ -1,5 +0,0 @@
-export declare function IndexSettings({ index }: {
-    index: {
-        name: string;
-    };
-}): import("react/jsx-runtime").JSX.Element;