@quantyapp/quanty-mcp-server 1.0.10 → 1.2.0

package/dist/core/budgetService.js

@@ -46,6 +46,7 @@ export async function getBudget(auth, budgetId) {
     return {
         id: data.id,
         title: data.title,
+        baseDate: data.data?.baseDate,
         createdAt: data.created_at,
         lastModified: data.last_modified,
         creator: data.creator,
@@ -99,7 +100,18 @@ export async function executeCreateBudget(auth, data) {
         deleted: false,
         data: {
             title: data.title,
-            rows: [],
+            // Cria 50 linhas vazias
+            rows: Array.from({ length: 50 }, () => ({
+                id: crypto.randomUUID(),
+                level: 0,
+                code: '',
+                description: '',
+                unit: '',
+                quantity: 0,
+                unitCost: 0,
+                isComposition: false,
+                bdiType: 'Principal'
+            })),
             bdi: 0,
             bdiItems: [],
             bdiPrincipal: 0,
@@ -129,6 +141,41 @@ export function prepareAddItem(budgetId, item) {
         data: { budgetId, item }
     };
 }
+/**
+ * Prepares adding a COMPOSITION (with inputs) to a budget
+ */
+export function prepareAddComposition(budgetId, composition) {
+    // Calcula o custo unitário da composição somando os insumos
+    const unitCost = composition.insumos.reduce((sum, insumo) => sum + (insumo.quantity * insumo.unitCost), 0);
+    const total = composition.quantity * unitCost;
+    // Transforma insumos no formato do BudgetRow.composition
+    const compositionItems = composition.insumos.map(insumo => ({
+        id: crypto.randomUUID(),
+        code: insumo.code || '',
+        description: insumo.description,
+        unit: insumo.unit,
+        quantity: insumo.quantity,
+        unitCost: insumo.unitCost,
+        itemType: insumo.itemType || 'INSUMO'
+    }));
+    return {
+        action: 'add_item',
+        preview: `Criar composição "${composition.description}" (${composition.quantity} ${composition.unit} x R$ ${unitCost.toFixed(2)} = R$ ${total.toFixed(2)}) com ${composition.insumos.length} insumo(s)`,
+        data: {
+            budgetId,
+            item: {
+                code: composition.code || '',
+                description: composition.description,
+                unit: composition.unit,
+                quantity: composition.quantity,
+                unitCost: unitCost,
+                level: composition.level ?? 0,
+                isComposition: true,
+                composition: compositionItems
+            }
+        }
+    };
+}
 /**
  * Executes adding an item
  * CORRIGIDO: Busca dados RAW e preserva estrutura original do campo 'data'
@@ -140,7 +187,7 @@ export async function executeAddItem(auth, data) {
         throw new Error('Budget not found');
     const newRow = {
         id: crypto.randomUUID(),
-        level: 0,
+        level: data.item.level ?? 0,
         code: data.item.code || '',
         description: data.item.description,
         unit: data.item.unit,
@@ -149,10 +196,18 @@ export async function executeAddItem(auth, data) {
         isComposition: data.item.isComposition || false,
         composition: data.item.composition || undefined
     };
-    // Atualiza apenas o array de rows, mantendo toda a estrutura original
+    let rows = [...(rawData.rows || [])];
+    // Encontra primeira linha vazia e substitui
+    const emptyIndex = rows.findIndex((r) => !r.description && !r.code && (!r.quantity || r.quantity === 0));
+    if (emptyIndex >= 0) {
+        rows[emptyIndex] = newRow;
+    }
+    else {
+        rows.push(newRow);
+    }
     const updatedData = {
         ...rawData,
-        rows: [...(rawData.rows || []), newRow]
+        rows
     };
     const { error } = await supabase
         .from('budgets')
@@ -247,3 +302,572 @@ export async function getCompositionDetails(auth, budgetId, itemId) {
         is_composicao: !!(child.composition && child.composition.length > 0)
     }));
 }
+// ================ BDI FUNCTIONS ================
+/**
+ * Prepares updating BDI values for a budget
+ */
+export function prepareUpdateBdi(budgetId, bdiPrincipal, bdiDiferenciado) {
+    const changes = [];
+    if (bdiPrincipal !== undefined)
+        changes.push(`Principal: ${bdiPrincipal}%`);
+    if (bdiDiferenciado !== undefined)
+        changes.push(`Diferenciado: ${bdiDiferenciado}%`);
+    return {
+        action: 'update_bdi',
+        preview: `Ajustar BDI: ${changes.join(', ')}`,
+        data: { budgetId, bdiPrincipal, bdiDiferenciado }
+    };
+}
+/**
+ * Executes BDI update
+ */
+export async function executeUpdateBdi(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const updatedData = {
+        ...rawData,
+        bdiPrincipal: data.bdiPrincipal ?? rawData.bdiPrincipal ?? 0,
+        bdiDiferenciado: data.bdiDiferenciado ?? rawData.bdiDiferenciado ?? 0
+    };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to update BDI: ${error.message}`);
+}
+// ================ EDIT ITEM FUNCTIONS ================
+/**
+ * Prepares editing an existing item
+ */
+export function prepareEditItem(budgetId, itemId, updates) {
+    const changes = [];
+    if (updates.description !== undefined)
+        changes.push(`descrição`);
+    if (updates.unit !== undefined)
+        changes.push(`unidade: ${updates.unit}`);
+    if (updates.quantity !== undefined)
+        changes.push(`qtd: ${updates.quantity}`);
+    if (updates.unitCost !== undefined)
+        changes.push(`custo: R$ ${updates.unitCost.toFixed(2)}`);
+    if (updates.level !== undefined)
+        changes.push(`nível: ${updates.level}`);
+    if (updates.code !== undefined)
+        changes.push(`código: ${updates.code}`);
+    return {
+        action: 'edit_item',
+        preview: `Editar item: ${changes.join(', ')}`,
+        data: { budgetId, itemId, updates }
+    };
+}
+/**
+ * Executes item edit
+ */
+export async function executeEditItem(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const rows = [...(rawData.rows || [])];
+    const itemIndex = rows.findIndex((r) => r.id === data.itemId);
+    if (itemIndex === -1)
+        throw new Error('Item not found in budget');
+    // Apply updates
+    const item = rows[itemIndex];
+    const updates = data.updates;
+    if (updates.description !== undefined)
+        item.description = updates.description;
+    if (updates.unit !== undefined)
+        item.unit = updates.unit;
+    if (updates.quantity !== undefined)
+        item.quantity = updates.quantity;
+    if (updates.unitCost !== undefined)
+        item.unitCost = updates.unitCost;
+    if (updates.level !== undefined)
+        item.level = updates.level;
+    if (updates.code !== undefined)
+        item.code = updates.code;
+    rows[itemIndex] = item;
+    const updatedData = {
+        ...rawData,
+        rows
+    };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to edit item: ${error.message}`);
+}
+// ================ DUPLICATE BUDGET FUNCTIONS ================
+/**
+ * Prepares duplicating a budget
+ */
+export function prepareDuplicateBudget(auth, budgetId, newTitle) {
+    return {
+        action: 'duplicate_budget',
+        preview: `Duplicar orçamento como "${newTitle}"`,
+        data: { budgetId, newTitle, tenantId: auth.tenantId, userId: auth.userId, creator: auth.userName }
+    };
+}
+/**
+ * Executes budget duplication
+ */
+export async function executeDuplicateBudget(auth, data) {
+    // Get original budget
+    const { data: original, error: fetchError } = await supabase
+        .from('budgets')
+        .select('*')
+        .eq('id', data.budgetId)
+        .single();
+    if (fetchError || !original)
+        throw new Error('Original budget not found');
+    const now = new Date().toISOString();
+    const newBudget = {
+        title: data.newTitle,
+        tenant_id: data.tenantId,
+        user_id: data.userId,
+        creator: data.creator,
+        created_at: now,
+        last_modified: now,
+        shared: false,
+        deleted: false,
+        data: {
+            ...original.data,
+            title: data.newTitle
+        }
+    };
+    const { data: result, error } = await supabase
+        .from('budgets')
+        .insert(newBudget)
+        .select('id')
+        .single();
+    if (error)
+        throw new Error(`Failed to duplicate budget: ${error.message}`);
+    return result.id;
+}
+// ================ MOVE ITEM (CHANGE LEVEL) ================
+/**
+ * Prepares moving an item to a different level
+ */
+export function prepareMoveItem(budgetId, itemId, newLevel, itemDescription) {
+    return {
+        action: 'edit_item',
+        preview: `Mover "${itemDescription}" para nível ${newLevel}`,
+        data: {
+            budgetId,
+            itemId,
+            updates: { level: newLevel }
+        }
+    };
+}
+// ================ EDIT BUDGET (Title, BDI, Data Base) ================
+/**
+ * Prepares editing budget metadata
+ */
+export function prepareEditBudget(budgetId, updates) {
+    const changes = [];
+    if (updates.title !== undefined)
+        changes.push(`título: "${updates.title}"`);
+    if (updates.baseDate !== undefined)
+        changes.push(`data base: ${updates.baseDate}`);
+    if (updates.bdiPrincipal !== undefined)
+        changes.push(`BDI Principal: ${updates.bdiPrincipal}%`);
+    if (updates.bdiDiferenciado !== undefined)
+        changes.push(`BDI Diferenciado: ${updates.bdiDiferenciado}%`);
+    return {
+        action: 'edit_budget',
+        preview: `Editar orçamento: ${changes.join(', ')}`,
+        data: { budgetId, updates }
+    };
+}
+/**
+ * Executes budget metadata editing
+ */
+export async function executeEditBudget(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const updates = data.updates;
+    const updatePayload = {
+        last_modified: new Date().toISOString()
+    };
+    // Handle title (it's a column, not in data JSONB)
+    if (updates.title !== undefined) {
+        updatePayload.title = updates.title;
+    }
+    // Handle data JSONB fields
+    const newData = { ...rawData };
+    if (updates.baseDate !== undefined)
+        newData.baseDate = updates.baseDate;
+    if (updates.bdiPrincipal !== undefined)
+        newData.bdiPrincipal = updates.bdiPrincipal;
+    if (updates.bdiDiferenciado !== undefined)
+        newData.bdiDiferenciado = updates.bdiDiferenciado;
+    updatePayload.data = newData;
+    const { error } = await supabase
+        .from('budgets')
+        .update(updatePayload)
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to edit budget: ${error.message}`);
+}
+// ================ SET ITEM BDI TYPE ================
+/**
+ * Prepares setting BDI type for an item
+ */
+export function prepareSetBdiType(budgetId, itemId, bdiType, itemDescription) {
+    return {
+        action: 'edit_item',
+        preview: `Definir BDI ${bdiType} para "${itemDescription}"`,
+        data: {
+            budgetId,
+            itemId,
+            updates: { bdiType }
+        }
+    };
+}
+// ================ SET ABC CLASSIFICATION ================
+/**
+ * Prepares ABC classification for an item
+ */
+export function prepareSetAbcClassification(budgetId, itemId, classification, itemDescription) {
+    return {
+        action: 'set_abc_classification',
+        preview: `Classificar "${itemDescription}" como ${classification}`,
+        data: { budgetId, itemId, classification }
+    };
+}
+/**
+ * Executes ABC classification setting
+ */
+export async function executeSetAbcClassification(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const abcClassifications = rawData.abcClassifications || {};
+    abcClassifications[data.itemId] = data.classification;
+    const updatedData = {
+        ...rawData,
+        abcClassifications
+    };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to set ABC classification: ${error.message}`);
+}
+// ================ EDIT COMPOSITION INPUTS ================
+/**
+ * Prepares editing inputs of a composition
+ */
+export function prepareEditCompositionInput(budgetId, compositionId, inputId, updates, inputDescription) {
+    const changes = [];
+    if (updates.description !== undefined)
+        changes.push(`descrição`);
+    if (updates.quantity !== undefined)
+        changes.push(`qtd: ${updates.quantity}`);
+    if (updates.unitCost !== undefined)
+        changes.push(`custo: R$ ${updates.unitCost.toFixed(2)}`);
+    if (updates.unit !== undefined)
+        changes.push(`unidade: ${updates.unit}`);
+    return {
+        action: 'edit_composition_input',
+        preview: `Editar insumo "${inputDescription}": ${changes.join(', ')}`,
+        data: { budgetId, compositionId, inputId, updates }
+    };
+}
+/**
+ * Executes editing composition input
+ */
+export async function executeEditCompositionInput(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const rows = [...(rawData.rows || [])];
+    // Find the composition
+    const findAndUpdateInput = (items) => {
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (item.id === data.compositionId && item.composition) {
+                // Found the composition, now find and update the input
+                const inputIndex = item.composition.findIndex((inp) => inp.id === data.inputId);
+                if (inputIndex !== -1) {
+                    const input = item.composition[inputIndex];
+                    const updates = data.updates;
+                    if (updates.code !== undefined)
+                        input.code = updates.code;
+                    if (updates.description !== undefined)
+                        input.description = updates.description;
+                    if (updates.unit !== undefined)
+                        input.unit = updates.unit;
+                    if (updates.quantity !== undefined)
+                        input.quantity = updates.quantity;
+                    if (updates.unitCost !== undefined)
+                        input.unitCost = updates.unitCost;
+                    if (updates.itemType !== undefined)
+                        input.itemType = updates.itemType;
+                    item.composition[inputIndex] = input;
+                    // Recalculate composition unitCost
+                    item.unitCost = item.composition.reduce((sum, inp) => sum + (inp.quantity || 0) * (inp.unitCost || 0), 0);
+                    items[i] = item;
+                    return true;
+                }
+            }
+            // Recursively check nested compositions
+            if (item.composition && findAndUpdateInput(item.composition)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (!findAndUpdateInput(rows)) {
+        throw new Error('Input not found in composition');
+    }
+    const updatedData = { ...rawData, rows };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to edit composition input: ${error.message}`);
+}
+/**
+ * Prepares adding an input to a composition
+ */
+export function prepareAddCompositionInput(budgetId, compositionId, input) {
+    const total = input.quantity * input.unitCost;
+    return {
+        action: 'add_composition_input',
+        preview: `Adicionar insumo "${input.description}" (${input.quantity} ${input.unit} x R$ ${input.unitCost.toFixed(2)} = R$ ${total.toFixed(2)})`,
+        data: { budgetId, compositionId, input }
+    };
+}
+/**
+ * Executes adding input to composition
+ */
+export async function executeAddCompositionInput(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const rows = [...(rawData.rows || [])];
+    const findAndAddInput = (items) => {
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (item.id === data.compositionId) {
+                if (!item.composition)
+                    item.composition = [];
+                const newInput = {
+                    id: crypto.randomUUID(),
+                    code: data.input.code || '',
+                    description: data.input.description,
+                    unit: data.input.unit,
+                    quantity: data.input.quantity,
+                    unitCost: data.input.unitCost,
+                    itemType: data.input.itemType || 'INSUMO'
+                };
+                item.composition.push(newInput);
+                // Recalculate unitCost
+                item.unitCost = item.composition.reduce((sum, inp) => sum + (inp.quantity || 0) * (inp.unitCost || 0), 0);
+                item.isComposition = true;
+                items[i] = item;
+                return true;
+            }
+            if (item.composition && findAndAddInput(item.composition)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (!findAndAddInput(rows)) {
+        throw new Error('Composition not found');
+    }
+    const updatedData = { ...rawData, rows };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to add composition input: ${error.message}`);
+}
+/**
+ * Prepares removing an input from a composition
+ */
+export function prepareRemoveCompositionInput(budgetId, compositionId, inputId, inputDescription) {
+    return {
+        action: 'remove_composition_input',
+        preview: `Remover insumo "${inputDescription}" da composição`,
+        data: { budgetId, compositionId, inputId }
+    };
+}
+/**
+ * Executes removing input from composition
+ */
+export async function executeRemoveCompositionInput(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const rows = [...(rawData.rows || [])];
+    const findAndRemoveInput = (items) => {
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (item.id === data.compositionId && item.composition) {
+                const inputIndex = item.composition.findIndex((inp) => inp.id === data.inputId);
+                if (inputIndex !== -1) {
+                    item.composition.splice(inputIndex, 1);
+                    // Recalculate unitCost
+                    item.unitCost = item.composition.reduce((sum, inp) => sum + (inp.quantity || 0) * (inp.unitCost || 0), 0);
+                    items[i] = item;
+                    return true;
+                }
+            }
+            if (item.composition && findAndRemoveInput(item.composition)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (!findAndRemoveInput(rows)) {
+        throw new Error('Input not found in composition');
+    }
+    const updatedData = { ...rawData, rows };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to remove composition input: ${error.message}`);
+}
+// ================ CONVERT COST TO COMPOSITION ================
+/**
+ * Prepares converting a simple cost item to a composition
+ */
+export function prepareConvertToComposition(budgetId, itemId, itemDescription) {
+    return {
+        action: 'convert_to_composition',
+        preview: `Converter "${itemDescription}" para composição`,
+        data: { budgetId, itemId }
+    };
+}
+/**
+ * Executes converting a cost item to a composition
+ */
+export async function executeConvertToComposition(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const rows = [...(rawData.rows || [])];
+    const findAndConvert = (items) => {
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (item.id === data.itemId) {
+                // Convert to composition: set isComposition flag and initialize empty composition array
+                item.isComposition = true;
+                if (!item.composition) {
+                    // Create an initial input based on the item's current cost
+                    if (item.unitCost > 0) {
+                        item.composition = [{
+                                id: crypto.randomUUID(),
+                                code: '',
+                                description: 'Custo base',
+                                unit: item.unit || 'un',
+                                quantity: 1,
+                                unitCost: item.unitCost,
+                                itemType: 'INSUMO'
+                            }];
+                    }
+                    else {
+                        item.composition = [];
+                    }
+                }
+                items[i] = item;
+                return true;
+            }
+            if (item.composition && findAndConvert(item.composition)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (!findAndConvert(rows)) {
+        throw new Error('Item not found');
+    }
+    const updatedData = { ...rawData, rows };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to convert to composition: ${error.message}`);
+}
+// ================ CONVERT COMPOSITION TO COST ================
+/**
+ * Prepares converting a composition back to simple cost
+ */
+export function prepareConvertToCost(budgetId, itemId, itemDescription) {
+    return {
+        action: 'convert_to_cost',
+        preview: `Converter "${itemDescription}" para custo simples (remove insumos)`,
+        data: { budgetId, itemId }
+    };
+}
+/**
+ * Executes converting a composition back to cost
+ */
+export async function executeConvertToCost(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const rows = [...(rawData.rows || [])];
+    const findAndConvert = (items) => {
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (item.id === data.itemId) {
+                // Convert to cost: remove composition flag and array, keep current unitCost
+                item.isComposition = false;
+                delete item.composition;
+                items[i] = item;
+                return true;
+            }
+            if (item.composition && findAndConvert(item.composition)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (!findAndConvert(rows)) {
+        throw new Error('Item not found');
+    }
+    const updatedData = { ...rawData, rows };
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: updatedData,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to convert to cost: ${error.message}`);
+}