indas-ui 0.0.1 → 0.1.0

package/dist/lib/api/activity/remarks/remarks.js

@@ -0,0 +1,179 @@
+'use client';
+/**
+ * Remark Intelligence API client (remarkData)
+ *
+ * One row per document (Module + DocumentID); full trail in Metadata JSON.
+ * See docs/superpowers/specs/2026-06-05-remark-intelligence-design.md
+ */
+import APIClient from '../../core/client.js';
+// Backend sometimes returns multi-encoded JSON strings — unwrap up to 3 times.
+function parseList(data) {
+    let v = data;
+    for (let i = 0; i < 3 && typeof v === 'string'; i++) {
+        try {
+            v = JSON.parse(v);
+        }
+        catch {
+            return [];
+        }
+    }
+    return Array.isArray(v) ? v : [];
+}
+export class RemarkIntelligenceAPI {
+    // Full trail for one document, or null if none yet.
+    static async getRemarkData(module, documentId, session) {
+        try {
+            const res = await APIClient.get(`/api/remarks?module=${encodeURIComponent(module)}&documentID=${encodeURIComponent(String(documentId))}`, session);
+            const rows = parseList(res.data);
+            if (rows.length === 0)
+                return { success: true, data: null };
+            const row = rows[0];
+            let remarks = [];
+            let meta = row.Metadata;
+            for (let i = 0; i < 3 && typeof meta === 'string'; i++) {
+                try {
+                    meta = JSON.parse(meta);
+                }
+                catch {
+                    meta = null;
+                    break;
+                }
+            }
+            if (meta && Array.isArray(meta.remarks))
+                remarks = meta.remarks;
+            return { success: true, data: { ...row, remarks } };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load remarks' };
+        }
+    }
+    // All remark entries for a booking, consolidated across every module/stage
+    // (enquiry, quotation, revisions) — threaded by BookingNo. Returns a flat,
+    // chronologically-ordered trail with each entry tagged by its source module.
+    static async getRemarkDataByBooking(bookingNo, session, enquiry) {
+        try {
+            const params = new URLSearchParams({ bookingNo: String(bookingNo ?? '') });
+            if (enquiry?.enquiryNo)
+                params.set('enquiryNo', String(enquiry.enquiryNo));
+            if (enquiry?.enquiryID)
+                params.set('enquiryID', String(enquiry.enquiryID));
+            const res = await APIClient.get(`/api/remarks/bybooking?${params.toString()}`, session);
+            const rows = parseList(res.data);
+            // Canonical stage name per source module (overrides per-entry stage so the
+            // trail reads consistently — "Estimation", "Sales Enquiry", etc.).
+            const stageForModule = (mod, docName) => {
+                const m = (mod || '').toLowerCase();
+                if (m === 'enquiry' || m.includes('/enquiry'))
+                    return 'Enquiry Remark';
+                if (m === 'quotation' || m.includes('quote-panel') || m.includes('/costing/estimation'))
+                    return 'Estimation Remark';
+                return docName || mod || '';
+            };
+            const all = [];
+            for (const row of rows) {
+                let meta = row.Metadata;
+                for (let i = 0; i < 3 && typeof meta === 'string'; i++) {
+                    try {
+                        meta = JSON.parse(meta);
+                    }
+                    catch {
+                        meta = null;
+                        break;
+                    }
+                }
+                if (meta && Array.isArray(meta.remarks)) {
+                    const stage = stageForModule(row.Module, row.DocumentName);
+                    for (const e of meta.remarks) {
+                        all.push({ ...e, stage });
+                    }
+                }
+            }
+            all.sort((a, b) => (a.at || '').localeCompare(b.at || ''));
+            return { success: true, data: all.map((e, i) => ({ ...e, seq: i + 1 })) };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load remarks' };
+        }
+    }
+    // Latest-only summaries for a list of documents, one call.
+    static async getRemarkDataBatch(module, documentIds, session) {
+        try {
+            const res = await APIClient.post('/api/remarks/batch', { Module: module, DocumentIDs: documentIds.map(String) }, session);
+            const rows = parseList(res.data);
+            const map = {};
+            for (const r of rows)
+                map[String(r.DocumentID)] = r;
+            return { success: true, data: map };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load remarks' };
+        }
+    }
+    // Append a remark (or create the trail). Server computes seq/by/byName/at.
+    static async saveRemarkData(payload, session) {
+        try {
+            const res = await APIClient.post('/api/remarks', { ...payload, DocumentID: String(payload.DocumentID) }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to save remark' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to save remark' };
+        }
+    }
+    // Save attachment rows to the universal store (JobBookingAttachments), keyed by Module + DocumentID.
+    static async saveAttachments(payload, session) {
+        try {
+            const res = await APIClient.post('/api/remarks/attachments', { ...payload, DocumentID: String(payload.DocumentID) }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to save attachments' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to save attachments' };
+        }
+    }
+    // List saved attachment rows for a document.
+    static async getAttachments(module, documentId, session) {
+        try {
+            const res = await APIClient.get(`/api/remarks/attachments?module=${encodeURIComponent(module)}&documentID=${encodeURIComponent(String(documentId))}`, session);
+            const rows = parseList(res.data);
+            return { success: true, data: rows };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to load attachments' };
+        }
+    }
+    // Edit the last trail entry (server enforces: last entry, author, < 2h).
+    static async editRemarkData(module, documentId, seq, text, session) {
+        try {
+            const res = await APIClient.post('/api/remarks/edit', { Module: module, DocumentID: String(documentId), seq, text }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to edit remark' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to edit remark' };
+        }
+    }
+    // Delete the last trail entry (same guards as edit).
+    static async deleteRemarkData(module, documentId, seq, session) {
+        try {
+            const res = await APIClient.post('/api/remarks/delete', { Module: module, DocumentID: String(documentId), seq }, session);
+            const data = typeof res.data === 'string' ? res.data : '';
+            if (!res.success || data.toLowerCase().startsWith('fail')) {
+                return { success: false, error: res.error || data || 'Failed to delete remark' };
+            }
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : 'Failed to delete remark' };
+        }
+    }
+}

package/dist/lib/api/activity/storage.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Provider-agnostic file storage API client.
+ *
+ * Uploads go through the backend (/api/storage/upload), which reads the active
+ * provider from IntegrationConfig (code 'FileAttachments') and writes a
+ * JobBookingAttachments index row. Swapping providers is a backend config change;
+ * this client is unaffected.
+ */
+export interface StoredFile {
+    key: string;
+    fileName: string;
+    fileExtension: string;
+}
+export interface StorageUploadResult {
+    success: boolean;
+    files: StoredFile[];
+    errors: string[];
+}
+interface UploadParams {
+    module: string;
+    documentID: string | number;
+    documentName: string;
+    documentIDName: string;
+    indexRow?: boolean;
+}
+export declare function uploadFilesToStorage(files: File[], params: UploadParams, session: any): Promise<StorageUploadResult>;
+export declare function storageFileUrl(key: string): string;
+export {};

package/dist/lib/api/activity/storage.js

@@ -0,0 +1,79 @@
+'use client';
+/**
+ * Provider-agnostic file storage API client.
+ *
+ * Uploads go through the backend (/api/storage/upload), which reads the active
+ * provider from IntegrationConfig (code 'FileAttachments') and writes a
+ * JobBookingAttachments index row. Swapping providers is a backend config change;
+ * this client is unaffected.
+ */
+function authHeaders(session) {
+    const companyUsername = session?.user?.companyUsername;
+    const companyPassword = session?.user?.companyPassword;
+    const authHeader = companyUsername && companyPassword
+        ? `Basic ${btoa(`${companyUsername}:${companyPassword}`)}`
+        : '';
+    return {
+        Authorization: authHeader,
+        CompanyID: String(session?.user?.CompanyID || session?.user?.companyID || ''),
+        UserID: String(session?.user?.UserID || session?.user?.userID || ''),
+        ProductionUnitID: String(session?.productionUnitId || session?.user?.ProductionUnitID || session?.user?.productionUnitID || ''),
+        FYear: session?.fYear || session?.user?.FYear || session?.user?.fYear || '',
+    };
+}
+// Upload files to the configured store and index them against a document.
+export async function uploadFilesToStorage(files, params, session) {
+    if (!files || files.length === 0)
+        return { success: true, files: [], errors: [] };
+    try {
+        const form = new FormData();
+        form.append('module', params.module);
+        form.append('documentID', String(params.documentID));
+        form.append('documentName', params.documentName);
+        form.append('documentIDName', params.documentIDName);
+        form.append('indexRow', params.indexRow === false ? 'false' : 'true');
+        files.forEach((f) => form.append('file', f));
+        const baseURL = process.env.NEXT_PUBLIC_API_BASE_URL || '';
+        const res = await fetch(`${baseURL}/api/storage/upload`, {
+            method: 'POST',
+            headers: authHeaders(session),
+            body: form,
+        });
+        const text = await res.text();
+        if (!res.ok || text.toLowerCase().startsWith('fail') || text.toLowerCase().startsWith('"fail')) {
+            return { success: false, files: [], errors: [text || `Upload failed (${res.status})`] };
+        }
+        // Web API's Ok(jsonString) double-encodes: the body is a JSON string containing
+        // JSON. Parse repeatedly until we get an object (matches the remarks parseList).
+        let data = text;
+        for (let i = 0; i < 3 && typeof data === 'string'; i++) {
+            try {
+                data = JSON.parse(data);
+            }
+            catch {
+                data = null;
+                break;
+            }
+        }
+        if (!data || typeof data !== 'object') {
+            return { success: false, files: [], errors: ['Unexpected upload response'] };
+        }
+        return { success: !!data.success, files: data.files || [], errors: data.errors || [] };
+    }
+    catch (error) {
+        return { success: false, files: [], errors: [error instanceof Error ? error.message : 'Upload failed'] };
+    }
+}
+// Build the public URL for a stored file-attachment object key. The key is
+// provider-agnostic in the DB; the base lives in NEXT_PUBLIC_FILE_ATTACHMENT_BASE_URL so a
+// provider switch is an env change, not a data migration. Each path segment is encoded.
+export function storageFileUrl(key) {
+    if (!key)
+        return '';
+    // Already a full URL (legacy rows that stored the URL) — use as-is.
+    if (/^https?:\/\//i.test(key))
+        return key;
+    const base = (process.env.NEXT_PUBLIC_FILE_ATTACHMENT_BASE_URL || '').replace(/\/+$/, '');
+    const encodedKey = key.split('/').map(encodeURIComponent).join('/');
+    return base ? `${base}/${encodedKey}` : encodedKey;
+}

package/dist/lib/api/ai/chat.d.ts

@@ -0,0 +1,67 @@
+/**
+ * AI Chat API Functions
+ * Connects to main backend for Parksons AI chat (ParksonsBotController)
+ */
+import type { APIResponse } from '../core/types.js';
+import type { Conversation, ChatMessageResponse, TokenUsage, UIDataEntry, HelpCombinationCategory } from './types.js';
+export interface ChatMessageParams {
+    message: string;
+    conversationId?: number;
+    newChat?: boolean;
+    title?: string | null;
+    phone?: string;
+}
+/**
+ * Send a chat message to the AI
+ * Returns standard APIResponse plus optional userMessageId from X-User-MessageID header
+ */
+export declare function sendChatMessageAPI(params: ChatMessageParams, sessionData: any, signal?: AbortSignal): Promise<APIResponse<string> & {
+    userMessageId?: string;
+    conversationId?: number;
+    tokens?: TokenUsage;
+    ui_data?: UIDataEntry[];
+}>;
+/**
+ * Get all conversations for current user
+ */
+export declare function getConversationsAPI(sessionData: any): Promise<APIResponse<Conversation[]>>;
+/**
+ * Get messages for a specific conversation
+ */
+export declare function getMessagesAPI(conversationId: number, sessionData: any): Promise<APIResponse<ChatMessageResponse[]>>;
+/**
+ * Delete all messages after a specific message in a conversation (cascade delete on edit/resend)
+ * Backend uses [HttpGet] route
+ */
+export declare function deleteMessagesAfterAPI(conversationId: number, messageId: string, sessionData: any): Promise<APIResponse<void>>;
+/**
+ * Rename a conversation
+ */
+export declare function renameConversationAPI(conversationId: number, title: string, sessionData: any): Promise<APIResponse<{
+    ConversationID: number;
+    Title: string;
+}>>;
+/**
+ * Toggle star (favorite) on a conversation — server flips the state and returns the new value
+ */
+export declare function toggleStarConversationAPI(conversationId: number, sessionData: any): Promise<APIResponse<{
+    ConversationID: number;
+    IsStarred: 0 | 1;
+}>>;
+export declare function getHelpCombinationsAPI(sessionData: any, opts?: {
+    contentType?: string;
+    contentId?: number;
+}): Promise<APIResponse<HelpCombinationCategory[]>>;
+/**
+ * Submit thumbs up/down feedback on an AI message. Pass null to clear.
+ */
+export declare function submitMessageFeedbackAPI(messageId: string, rating: 'up' | 'down' | null, sessionData: any): Promise<APIResponse<void>>;
+/**
+ * Delete a conversation
+ * Backend uses [HttpGet] route
+ */
+export declare function deleteConversationAPI(conversationId: number, sessionData: any): Promise<APIResponse<void>>;
+export declare function duplicateConversationAPI(conversationId: number, sessionData: any): Promise<APIResponse<{
+    ConversationID: number;
+    Title: string;
+}>>;

package/dist/lib/api/ai/chat.js

@@ -0,0 +1,212 @@
+'use client';
+/**
+ * AI Chat API Functions
+ * Connects to main backend for Parksons AI chat (ParksonsBotController)
+ */
+import APIClient from '../core/client.js';
+/**
+ * Send a chat message to the AI
+ * Returns standard APIResponse plus optional userMessageId from X-User-MessageID header
+ */
+export async function sendChatMessageAPI(params, sessionData, signal) {
+    try {
+        // Costingbot turns can take 30-90s when the model chains multiple tools
+        // (validation → costing → freight). The default 60s timeout aborts legit
+        // turns mid-flight, leaving the server with a half-finished AiMessages row
+        // and no assistant reply. 3 minutes is a sane upper bound — the user's
+        // Stop button (signal) is the meaningful cancel for normal use.
+        const response = await APIClient.post('/api/synthia/costingbot', {
+            message: params.message,
+            conversationId: params.conversationId,
+            newChat: params.newChat,
+            title: params.title,
+            phone: params.phone || sessionData?.user?.UserID?.toString() || '9999999999'
+        }, sessionData, undefined, signal, 180000);
+        // Try to extract tokens + ui_data if backend returns JSON with { message, tokens, ui_data }
+        let tokens;
+        let ui_data;
+        let messageContent = response.data;
+        if (typeof response.data === 'string') {
+            try {
+                const parsed = JSON.parse(response.data);
+                if (parsed.message && parsed.tokens) {
+                    messageContent = parsed.message;
+                    tokens = parsed.tokens;
+                    if (Array.isArray(parsed.ui_data)) {
+                        ui_data = parsed.ui_data.filter((e) => e.version === 1);
+                    }
+                }
+            }
+            catch {
+                // Not JSON — plain string response, that's fine
+            }
+        }
+        else if (response.data && typeof response.data === 'object') {
+            const obj = response.data;
+            if (obj.message && obj.tokens) {
+                messageContent = obj.message;
+                tokens = obj.tokens;
+                if (Array.isArray(obj.ui_data)) {
+                    ui_data = obj.ui_data.filter(e => e.version === 1);
+                }
+            }
+        }
+        const convIdRaw = response.responseHeaders?.['X-Conversation-ID'];
+        const conversationId = convIdRaw ? Number(convIdRaw) : undefined;
+        return {
+            ...response,
+            data: messageContent,
+            userMessageId: response.responseHeaders?.['X-User-MessageID'],
+            conversationId: Number.isFinite(conversationId) ? conversationId : undefined,
+            tokens,
+            ui_data
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to send message'
+        };
+    }
+}
+/**
+ * Get all conversations for current user
+ */
+export async function getConversationsAPI(sessionData) {
+    try {
+        const response = await APIClient.get('/api/synthia/conversations', sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to load conversations'
+        };
+    }
+}
+/**
+ * Get messages for a specific conversation
+ */
+export async function getMessagesAPI(conversationId, sessionData) {
+    try {
+        const response = await APIClient.get(`/api/synthia/messages/${conversationId}`, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to load messages'
+        };
+    }
+}
+/**
+ * Delete all messages after a specific message in a conversation (cascade delete on edit/resend)
+ * Backend uses [HttpGet] route
+ */
+export async function deleteMessagesAfterAPI(conversationId, messageId, sessionData) {
+    try {
+        const response = await APIClient.get(`/api/synthia/delete-messages-after/${conversationId}/${messageId}`, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to delete messages'
+        };
+    }
+}
+/**
+ * Rename a conversation
+ */
+export async function renameConversationAPI(conversationId, title, sessionData) {
+    try {
+        const response = await APIClient.post(`/api/synthia/rename-conversation/${conversationId}`, { title }, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to rename conversation'
+        };
+    }
+}
+/**
+ * Toggle star (favorite) on a conversation — server flips the state and returns the new value
+ */
+export async function toggleStarConversationAPI(conversationId, sessionData) {
+    try {
+        const response = await APIClient.post(`/api/synthia/toggle-star/${conversationId}`, undefined, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to toggle star'
+        };
+    }
+}
+export async function getHelpCombinationsAPI(sessionData, opts) {
+    try {
+        const params = [];
+        if (opts?.contentType)
+            params.push(`contentType=${encodeURIComponent(opts.contentType)}`);
+        if (opts?.contentId != null)
+            params.push(`contentId=${opts.contentId}`);
+        const qs = params.length > 0 ? `?${params.join('&')}` : '';
+        const response = await APIClient.get(`/api/synthia/help/combinations${qs}`, sessionData);
+        if (response.success && response.data && typeof response.data === 'object') {
+            const obj = response.data;
+            return { ...response, data: Array.isArray(obj.categories) ? obj.categories : [] };
+        }
+        return { ...response, data: [] };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to load categories'
+        };
+    }
+}
+/**
+ * Submit thumbs up/down feedback on an AI message. Pass null to clear.
+ */
+export async function submitMessageFeedbackAPI(messageId, rating, sessionData) {
+    try {
+        const response = await APIClient.post(`/api/synthia/messages/${messageId}/feedback`, { rating }, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to submit feedback'
+        };
+    }
+}
+/**
+ * Delete a conversation
+ * Backend uses [HttpGet] route
+ */
+export async function deleteConversationAPI(conversationId, sessionData) {
+    try {
+        const response = await APIClient.get(`/api/synthia/delete-conversation/${conversationId}`, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to delete conversation'
+        };
+    }
+}
+export async function duplicateConversationAPI(conversationId, sessionData) {
+    try {
+        const response = await APIClient.post(`/api/synthia/duplicate-conversation/${conversationId}`, {}, sessionData);
+        return response;
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to duplicate conversation'
+        };
+    }
+}

package/dist/lib/api/ai/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * AI Chat API Types
+ */
+export interface TokenUsage {
+    prompt: number;
+    completion: number;
+    total: number;
+}
+export interface UIDataItem {
+    index: number;
+    id: string | number;
+    name: string;
+    [key: string]: unknown;
+}
+export interface UIDataEntry {
+    version: number;
+    id: string;
+    type: 'dropdown' | 'multiselect' | string;
+    tool: string;
+    items: UIDataItem[];
+    display_header?: string;
+    selected_ids?: (string | number)[];
+}
+export interface Message {
+    id: string;
+    conversationId: number;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    timestamp: Date;
+    contentType: 'text' | 'image' | 'file';
+    tokens?: TokenUsage;
+    ui_data?: UIDataEntry[];
+    uiDataReadonly?: boolean;
+    feedback?: 'up' | 'down' | null;
+}
+export interface Conversation {
+    ConversationID: number;
+    Title: string;
+    Status?: string;
+    CreatedAt?: string;
+    LastActivityAt?: string;
+    ContactNo?: string;
+    IsStarred?: 0 | 1 | boolean;
+}
+export interface HelpCombinationProcess {
+    process: string;
+    materials: string[];
+}
+export interface HelpCombinationCategory {
+    category: string;
+    code?: string;
+    processes: HelpCombinationProcess[];
+}
+export interface HelpCombinationsResponse {
+    success: boolean;
+    count: number;
+    categories: HelpCombinationCategory[];
+}
+export interface ChatMessageResponse {
+    MessageID: number;
+    ConversationID: number;
+    Role: 'user' | 'assistant' | 'system' | 'tool';
+    MessageContent?: string;
+    Content?: string;
+    CreatedAt: string;
+    ToolName?: string | null;
+    ToolCallID?: string | null;
+    Feedback?: 1 | 0 | null;
+}

package/dist/lib/api/ai/types.js

@@ -0,0 +1,5 @@
+'use client';
+/**
+ * AI Chat API Types
+ */
+export {};