hale-commenting-system 1.0.2 → 1.0.4

package/dist/index.d.ts

@@ -1,87 +1,186 @@
-import React from 'react';
+import * as React from 'react';
 
 interface CommentOverlayProps {
     selectedThreadId: string | null;
-    onThreadSelect: (threadId: string | null) => void;
+    onThreadSelect: (id: string) => void;
 }
-declare const CommentOverlay: React.FC<CommentOverlayProps>;
+declare const CommentOverlay: React.FunctionComponent<CommentOverlayProps>;
 
 interface CommentDrawerProps {
-    selectedThreadId: string | null;
-    onThreadSelect: (threadId: string | null) => void;
     children: React.ReactNode;
+    selectedThreadId: string | null;
+    onThreadSelect: (id: string | null) => void;
 }
-declare const CommentDrawer: React.FC<CommentDrawerProps>;
+declare const CommentDrawer: React.FunctionComponent<CommentDrawerProps>;
 
-declare const CommentPin: React.FC;
+type SyncStatus = 'synced' | 'local' | 'pending' | 'syncing' | 'error';
+interface Comment {
+    id: string;
+    author?: string;
+    text: string;
+    createdAt: string;
+    githubCommentId?: number;
+}
+interface Thread {
+    id: string;
+    x: number;
+    y: number;
+    route: string;
+    comments: Comment[];
+    issueNumber?: number;
+    syncStatus: SyncStatus;
+    syncError?: string;
+    version?: string;
+    provider?: 'github' | 'gitlab';
+}
+interface CommentContextType {
+    threads: Thread[];
+    showPins: boolean;
+    enableCommenting: boolean;
+    toggleShowPins: () => void;
+    toggleEnableCommenting: () => void;
+    addThread: (x: number, y: number, route: string, version?: string) => string;
+    addReply: (threadId: string, text: string) => Promise<void>;
+    updateComment: (threadId: string, commentId: string, text: string) => Promise<void>;
+    deleteComment: (threadId: string, commentId: string) => Promise<void>;
+    deleteThread: (threadId: string) => Promise<void>;
+    clearAllThreads: () => void;
+    getThreadsForRoute: (route: string, version?: string) => Thread[];
+    syncFromGitHub: (route: string) => Promise<void>;
+    retrySync: () => Promise<void>;
+    isSyncing: boolean;
+    hasPendingSync: boolean;
+}
+declare const CommentProvider: React.FunctionComponent<{
+    children: React.ReactNode;
+}>;
+declare const useComments: () => CommentContextType;
 
-declare const AIAssistant: React.FC;
+interface CommentPinProps {
+    thread: Thread;
+    onPinClick: () => void;
+    isSelected?: boolean;
+}
+declare const CommentPin: React.FunctionComponent<CommentPinProps>;
 
-declare const AIChatPanel: React.FC;
+declare const AIAssistant: React.FunctionComponent;
 
-declare const CommentProvider: React.FC<{
-    children: React.ReactNode;
-}>;
-declare const useComments: () => any;
+declare const AIChatPanel: React.FunctionComponent;
 
-declare const VersionProvider: React.FC<{
+interface VersionContextType {
+    currentVersion: string;
+    setCurrentVersion: (version: string) => void;
+}
+declare const VersionProvider: React.FunctionComponent<{
     children: React.ReactNode;
 }>;
-declare const useVersion: () => any;
+declare const useVersion: () => VersionContextType;
 
+interface GitHubUser {
+    login: string;
+    avatar: string;
+}
+interface GitHubAuthContextType {
+    user: GitHubUser | null;
+    isAuthenticated: boolean;
+    login: () => void;
+    logout: () => void;
+}
 declare const GitHubAuthProvider: React.FC<{
     children: React.ReactNode;
-    config?: any;
 }>;
-declare const useGitHubAuth: () => any;
+declare const useGitHubAuth: () => GitHubAuthContextType;
 
+interface GitLabUser {
+    username?: string;
+    avatar?: string;
+}
+interface GitLabAuthContextType {
+    user: GitLabUser | null;
+    isAuthenticated: boolean;
+    login: () => void;
+    logout: () => void;
+    getToken: () => string | null;
+}
 declare const GitLabAuthProvider: React.FC<{
     children: React.ReactNode;
 }>;
-declare const useGitLabAuth: () => any;
+declare const useGitLabAuth: () => GitLabAuthContextType;
 
-declare const AIProvider: React.FC<{
+interface AIMessage {
+    id: string;
+    role: 'user' | 'bot';
+    content: string;
+    timestamp: string;
+}
+interface AIContextType {
+    isChatbotVisible: boolean;
+    messages: AIMessage[];
+    isLoading: boolean;
+    toggleChatbot: () => void;
+    sendMessage: (content: string, commentContext?: {
+        threads: any[];
+        version: string;
+        route?: string;
+    }) => Promise<void>;
+    clearHistory: () => void;
+}
+declare const AIProvider: React.FunctionComponent<{
     children: React.ReactNode;
 }>;
-declare const useAIContext: () => any;
+declare const useAIContext: () => AIContextType;
 
-declare const githubAdapter: {};
 declare const isGitHubConfigured: () => boolean;
-
-declare const gitlabAdapter: {};
-declare const isGitLabConfigured: () => boolean;
-
-interface Comment {
-    id: string;
-    text: string;
-    author: string;
-    timestamp: Date;
-    threadId: string;
-}
-interface Thread {
-    id: string;
-    comments: Comment[];
-    position: {
-        x: number;
-        y: number;
-    };
-    status: 'open' | 'resolved';
-}
-interface SyncStatus {
-    synced: boolean;
-    lastSync?: Date;
+interface GitHubResult<T = any> {
+    success: boolean;
+    data?: T;
     error?: string;
 }
-interface AIMessage {
-    id: string;
-    role: 'user' | 'assistant';
-    content: string;
-    timestamp: Date;
-}
-interface GitHubResult {
+declare const githubAdapter: {
+    /**
+     * Create a new GitHub Issue for a comment thread
+     */
+    createIssue(title: string, body: string, route: string, x: number, y: number, version?: string): Promise<GitHubResult>;
+    /**
+     * Add a comment to an existing GitHub Issue
+     */
+    createComment(issueNumber: number, body: string): Promise<GitHubResult>;
+    /**
+     * Fetch all issues for a specific route
+     */
+    fetchIssues(route: string): Promise<any>;
+    /**
+     * Fetch all comments for a specific issue
+     */
+    fetchComments(issueNumber: number): Promise<any>;
+    /**
+     * Close a GitHub Issue (when deleting a thread)
+     */
+    closeIssue(issueNumber: number): Promise<GitHubResult>;
+    /**
+     * Update an existing comment on a GitHub Issue
+     */
+    updateComment(commentId: number, body: string): Promise<GitHubResult>;
+    /**
+     * Delete a comment on a GitHub Issue
+     */
+    deleteComment(commentId: number): Promise<GitHubResult>;
+};
+
+declare const isGitLabConfigured: () => boolean;
+interface GitLabResult<T = any> {
     success: boolean;
-    issueNumber?: number;
+    data?: T;
     error?: string;
 }
+declare const gitlabAdapter: {
+    createIssue(title: string, body: string, route: string, x: number, y: number, version?: string): Promise<GitLabResult>;
+    createComment(issueNumber: number, body: string): Promise<GitLabResult>;
+    updateComment(commentId: number, body: string): Promise<GitLabResult>;
+    deleteComment(commentId: number): Promise<GitLabResult>;
+    closeIssue(issueNumber: number): Promise<GitLabResult>;
+    fetchIssues(route: string): Promise<any>;
+    fetchComments(issueNumber: number): Promise<any>;
+};
 
 export { AIAssistant, AIChatPanel, type AIMessage, AIProvider, type Comment, CommentDrawer, CommentOverlay, CommentPin, CommentProvider, GitHubAuthProvider, type GitHubResult, GitLabAuthProvider, type SyncStatus, type Thread, VersionProvider, githubAdapter, gitlabAdapter, isGitHubConfigured, isGitLabConfigured, useAIContext, useComments, useGitHubAuth, useGitLabAuth, useVersion };