@quantyapp/quanty-mcp-server 1.0.11 → 1.2.6

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,
@@ -53,7 +54,9 @@ export async function getBudget(auth, budgetId) {
         projectId: data.project_id,
         rows: data.data?.rows || [],
         bdiPrincipal: data.data?.bdiPrincipal || 0,
-        bdiDiferenciado: data.data?.bdiDiferenciado || 0
+        bdiDiferenciado: data.data?.bdiDiferenciado || 0,
+        bdiItemsPrincipal: data.data?.bdiItemsPrincipal || [],
+        bdiItemsDiferenciado: data.data?.bdiItemsDiferenciado || []
     };
 }
 /**
@@ -88,6 +91,9 @@ export function prepareCreateBudget(auth, title) {
  */
 export async function executeCreateBudget(auth, data) {
     const now = new Date().toISOString();
+    // Gera a data base padrão no formato MM/AAAA
+    const nowDate = new Date();
+    const defaultBaseDate = `${String(nowDate.getMonth() + 1).padStart(2, '0')}/${nowDate.getFullYear()}`;
     const budgetData = {
         title: data.title,
         tenant_id: data.tenantId,
@@ -99,6 +105,7 @@ export async function executeCreateBudget(auth, data) {
         deleted: false,
         data: {
             title: data.title,
+            baseDate: defaultBaseDate, // Data Base padrão = data de criação
             // Cria 50 linhas vazias
             rows: Array.from({ length: 50 }, () => ({
                 id: crypto.randomUUID(),
@@ -140,6 +147,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'
@@ -151,7 +193,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,
@@ -266,3 +308,979 @@ 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}`);
+}
+/**
+ * Calcula o BDI total baseado nos itens de composição
+ * Fórmula: BDI = ((1 + i_custo) / (1 - i_venda) - 1) * 100
+ *
+ * Onde:
+ * - i_custo = soma dos % que incidem sobre o Custo (ex: Administração, Risco)
+ * - i_venda = soma dos % que incidem sobre a Venda (ex: ISS, PIS, COFINS, Lucro)
+ */
+export function calculateBdiTotal(items) {
+    if (!items || items.length === 0)
+        return 0;
+    let i_custo = 0;
+    let i_venda = 0;
+    items.forEach(item => {
+        const val = item.percentage / 100;
+        if (item.incidence === 'Custo') {
+            i_custo += val;
+        }
+        else {
+            // 'Venda' ou qualquer outro valor incide sobre venda
+            i_venda += val;
+        }
+    });
+    // Safety check to prevent division by zero or negative results
+    if (i_venda >= 1) {
+        return 0;
+    }
+    const bdi = (((1 + i_custo) / (1 - i_venda)) - 1) * 100;
+    return bdi;
+}
+/**
+ * Prepares adding an item to BDI composition
+ */
+export function prepareAddBdiItem(budgetId, bdiType, item) {
+    return {
+        action: 'add_bdi_item',
+        preview: `Adicionar item ao BDI ${bdiType}: "${item.description}" (${item.percentage}%)`,
+        data: { budgetId, bdiType, item }
+    };
+}
+/**
+ * Executes adding item to BDI composition
+ * ATUALIZADO: Recalcula automaticamente o BDI total
+ */
+export async function executeAddBdiItem(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const bdiField = data.bdiType === 'Principal' ? 'bdiItemsPrincipal' : 'bdiItemsDiferenciado';
+    const bdiValueField = data.bdiType === 'Principal' ? 'bdiPrincipal' : 'bdiDiferenciado';
+    const currentItems = rawData[bdiField] || [];
+    const newItem = {
+        id: crypto.randomUUID(),
+        description: data.item.description,
+        percentage: data.item.percentage,
+        incidence: data.item.incidence
+    };
+    const updatedItems = [...currentItems, newItem];
+    const newBdiTotal = calculateBdiTotal(updatedItems);
+    const updatedData = {
+        ...rawData,
+        [bdiField]: updatedItems,
+        [bdiValueField]: newBdiTotal
+    };
+    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 BDI item: ${error.message}`);
+}
+/**
+ * Prepares editing an existing BDI item
+ */
+export function prepareEditBdiItem(budgetId, bdiType, itemId, updates) {
+    const changes = [];
+    if (updates.description !== undefined)
+        changes.push(`descrição: "${updates.description}"`);
+    if (updates.percentage !== undefined)
+        changes.push(`percentual: ${updates.percentage}%`);
+    if (updates.incidence !== undefined)
+        changes.push(`incidência: ${updates.incidence}`);
+    return {
+        action: 'edit_bdi_item',
+        preview: `Editar item do BDI ${bdiType}: ${changes.join(', ')}`,
+        data: { budgetId, bdiType, itemId, updates }
+    };
+}
+/**
+ * Executes editing BDI item
+ * ATUALIZADO: Recalcula automaticamente o BDI total
+ */
+export async function executeEditBdiItem(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const bdiField = data.bdiType === 'Principal' ? 'bdiItemsPrincipal' : 'bdiItemsDiferenciado';
+    const bdiValueField = data.bdiType === 'Principal' ? 'bdiPrincipal' : 'bdiDiferenciado';
+    const items = [...(rawData[bdiField] || [])];
+    const itemIndex = items.findIndex((item) => item.id === data.itemId);
+    if (itemIndex === -1)
+        throw new Error('BDI item not found');
+    items[itemIndex] = {
+        ...items[itemIndex],
+        ...data.updates
+    };
+    const newBdiTotal = calculateBdiTotal(items);
+    const updatedData = {
+        ...rawData,
+        [bdiField]: items,
+        [bdiValueField]: newBdiTotal
+    };
+    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 BDI item: ${error.message}`);
+}
+/**
+ * Prepares removing an item from BDI composition
+ */
+export function prepareRemoveBdiItem(budgetId, bdiType, itemId, itemDescription) {
+    return {
+        action: 'remove_bdi_item',
+        preview: `Remover item do BDI ${bdiType}: "${itemDescription}"`,
+        data: { budgetId, bdiType, itemId }
+    };
+}
+/**
+ * Executes removing BDI item
+ * ATUALIZADO: Recalcula automaticamente o BDI total
+ */
+export async function executeRemoveBdiItem(auth, data) {
+    const rawData = await getRawBudgetData(data.budgetId);
+    if (!rawData)
+        throw new Error('Budget not found');
+    const bdiField = data.bdiType === 'Principal' ? 'bdiItemsPrincipal' : 'bdiItemsDiferenciado';
+    const bdiValueField = data.bdiType === 'Principal' ? 'bdiPrincipal' : 'bdiDiferenciado';
+    const items = [...(rawData[bdiField] || [])];
+    const filteredItems = items.filter((item) => item.id !== data.itemId);
+    const newBdiTotal = calculateBdiTotal(filteredItems);
+    const updatedData = {
+        ...rawData,
+        [bdiField]: filteredItems,
+        [bdiValueField]: newBdiTotal
+    };
+    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 BDI item: ${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;
+    if (updates.bdiType !== undefined)
+        item.bdiType = updates.bdiType;
+    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}`);
+}
+/**
+ * Lists all tags for a specific budget
+ */
+export async function getTagsForBudget(budgetId) {
+    const { data, error } = await supabase
+        .from('budget_tags')
+        .select('*')
+        .eq('budget_id', budgetId)
+        .order('created_at', { ascending: true });
+    if (error) {
+        console.error('Error fetching tags:', error);
+        return [];
+    }
+    return data || [];
+}
+/**
+ * Prepares adding a tag to a budget
+ */
+export function prepareAddTag(budgetId, name) {
+    return {
+        action: 'add_tag',
+        preview: `Adicionar rótulo "${name}" ao orçamento`,
+        data: { budgetId, name }
+    };
+}
+/**
+ * Executes adding a tag
+ */
+export async function executeAddTag(auth, data) {
+    const { data: tag, error } = await supabase
+        .from('budget_tags')
+        .insert({ budget_id: data.budgetId, name: data.name })
+        .select()
+        .single();
+    if (error)
+        throw new Error(`Failed to add tag: ${error.message}`);
+    // Update last_modified on budget
+    await supabase
+        .from('budgets')
+        .update({ last_modified: new Date().toISOString() })
+        .eq('id', data.budgetId);
+    return tag;
+}
+/**
+ * Prepares editing a tag
+ */
+export function prepareEditTag(tagId, newName, currentName) {
+    return {
+        action: 'edit_tag',
+        preview: `Renomear rótulo de "${currentName}" para "${newName}"`,
+        data: { tagId, newName }
+    };
+}
+/**
+ * Executes editing a tag
+ */
+export async function executeEditTag(auth, data) {
+    const { error } = await supabase
+        .from('budget_tags')
+        .update({ name: data.newName })
+        .eq('id', data.tagId);
+    if (error)
+        throw new Error(`Failed to edit tag: ${error.message}`);
+}
+/**
+ * Prepares removing a tag
+ */
+export function prepareRemoveTag(tagId, tagName) {
+    return {
+        action: 'remove_tag',
+        preview: `Remover rótulo "${tagName}"`,
+        data: { tagId }
+    };
+}
+/**
+ * Executes removing a tag
+ */
+export async function executeRemoveTag(auth, data) {
+    const { error } = await supabase
+        .from('budget_tags')
+        .delete()
+        .eq('id', data.tagId);
+    if (error)
+        throw new Error(`Failed to remove tag: ${error.message}`);
+}
+/**
+ * Lists all projects for the authenticated user's tenant
+ */
+export async function getProjects(auth) {
+    const { data, error } = await supabase
+        .from('projects')
+        .select('*')
+        .eq('deleted', false)
+        .order('created_at', { ascending: false });
+    if (error) {
+        console.error('Error fetching projects:', error);
+        return [];
+    }
+    return (data || []).map(p => ({
+        id: p.id,
+        code: p.code,
+        name: p.name,
+        description: p.description,
+        created_at: p.created_at,
+        updated_at: p.updated_at
+    }));
+}
+/**
+ * Prepares creating a new project
+ */
+export function prepareCreateProject(name, description, code) {
+    return {
+        action: 'create_project',
+        preview: `Criar projeto "${name}"${code ? ` (${code})` : ''}`,
+        data: { name, description, code }
+    };
+}
+/**
+ * Executes creating a project
+ */
+export async function executeCreateProject(auth, data) {
+    const now = new Date().toISOString();
+    const newProject = {
+        id: crypto.randomUUID(),
+        name: data.name,
+        description: data.description || '',
+        code: data.code || null,
+        user_id: auth.userId,
+        created_at: now,
+        updated_at: now,
+        deleted: false
+    };
+    const { data: project, error } = await supabase
+        .from('projects')
+        .insert(newProject)
+        .select()
+        .single();
+    if (error)
+        throw new Error(`Failed to create project: ${error.message}`);
+    return {
+        id: project.id,
+        code: project.code,
+        name: project.name,
+        description: project.description,
+        created_at: project.created_at,
+        updated_at: project.updated_at
+    };
+}
+/**
+ * Prepares editing a project
+ */
+export function prepareEditProject(projectId, updates, currentName) {
+    const changes = [];
+    if (updates.name)
+        changes.push(`nome: "${updates.name}"`);
+    if (updates.description !== undefined)
+        changes.push(`descrição`);
+    if (updates.code !== undefined)
+        changes.push(`código: "${updates.code}"`);
+    return {
+        action: 'edit_project',
+        preview: `Editar projeto "${currentName}": ${changes.join(', ')}`,
+        data: { projectId, updates }
+    };
+}
+/**
+ * Executes editing a project
+ */
+export async function executeEditProject(auth, data) {
+    const updatePayload = {
+        updated_at: new Date().toISOString()
+    };
+    if (data.updates.name !== undefined)
+        updatePayload.name = data.updates.name;
+    if (data.updates.description !== undefined)
+        updatePayload.description = data.updates.description;
+    if (data.updates.code !== undefined)
+        updatePayload.code = data.updates.code;
+    const { error } = await supabase
+        .from('projects')
+        .update(updatePayload)
+        .eq('id', data.projectId);
+    if (error)
+        throw new Error(`Failed to edit project: ${error.message}`);
+}
+/**
+ * Prepares deleting a project (soft delete)
+ */
+export function prepareDeleteProject(projectId, projectName) {
+    return {
+        action: 'delete_project',
+        preview: `Excluir projeto "${projectName}" (orçamentos serão desvinculados)`,
+        data: { projectId }
+    };
+}
+/**
+ * Executes deleting a project (soft delete)
+ */
+export async function executeDeleteProject(auth, data) {
+    // First, unlink all budgets from this project
+    const { error: unlinkError } = await supabase
+        .from('budgets')
+        .update({ project_id: null })
+        .eq('project_id', data.projectId);
+    if (unlinkError) {
+        console.error('Error unlinking budgets:', unlinkError);
+    }
+    // Soft delete the project
+    const { error } = await supabase
+        .from('projects')
+        .update({ deleted: true })
+        .eq('id', data.projectId);
+    if (error)
+        throw new Error(`Failed to delete project: ${error.message}`);
+}
+/**
+ * Prepares linking a budget to a project
+ */
+export function prepareLinkBudgetToProject(budgetId, projectId, budgetTitle, projectName) {
+    const preview = projectId
+        ? `Vincular orçamento "${budgetTitle}" ao projeto "${projectName}"`
+        : `Desvincular orçamento "${budgetTitle}" de qualquer projeto`;
+    return {
+        action: 'link_budget_to_project',
+        preview,
+        data: { budgetId, projectId }
+    };
+}
+/**
+ * Executes linking a budget to a project
+ */
+export async function executeLinkBudgetToProject(auth, data) {
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        project_id: data.projectId,
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to link budget to project: ${error.message}`);
+}