@quantyapp/quanty-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,65 @@
+# Quanty MCP Server
+
+Servidor MCP que conecta o Claude Desktop ao Quanty.
+
+## Instalação
+
+```bash
+cd quanty-mcp-server
+npm install
+npm run build
+```
+
+## Configuração no Claude Desktop
+
+1. Gere seu token no Quanty: **Minha Conta → Conexão MCP → Gerar Token**
+
+2. Edite o arquivo `claude_desktop_config.json`:
+   - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+   - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+3. Adicione a configuração:
+
+```json
+{
+  "mcpServers": {
+    "quanty": {
+      "command": "node",
+      "args": ["C:/Users/romar/OneDrive/Documentos/B2Builder/Quanty/quanty-mcp-server/dist/mcp/index.js"],
+      "env": {
+        "QUANTY_MCP_TOKEN": "seu-token-aqui",
+        "SUPABASE_URL": "https://aimquvsavkffqgctnzym.supabase.co",
+        "SUPABASE_SERVICE_ROLE_KEY": "sua-service-key-aqui"
+      }
+    }
+  }
+}
+```
+
+4. Reinicie o Claude Desktop
+
+## Tools Disponíveis
+
+### Leitura
+- `quanty_listar_orcamentos` - Lista orçamentos recentes
+- `quanty_abrir_orcamento` - Detalhes de um orçamento
+- `quanty_listar_bancos` - Lista bancos de composição
+- `quanty_buscar_insumo` - Busca insumos em banco
+
+### Escrita (com confirmação)
+- `quanty_preparar_orcamento` - Prepara criação
+- `quanty_preparar_item` - Prepara adição de item
+- `quanty_executar` - Confirma operação
+
+### Análise
+- `quanty_orcamentos_similares` - Encontra similares
+- `quanty_sugerir_itens` - Sugere itens faltantes
+- `quanty_custo_medio` - Custo médio por unidade
+
+## Exemplo de Uso
+
+No Claude Desktop, diga:
+- "Liste meus orçamentos no Quanty"
+- "Crie um orçamento chamado 'Ponte Rio Novo'"
+- "Busque 'concreto fck 30' no banco SINAPI"
+- "Sugira itens que podem estar faltando no orçamento X"

package/dist/core/analysisService.d.ts

@@ -0,0 +1,35 @@
+import { AuthContext } from './auth.js';
+export interface SimilarBudget {
+    id: string;
+    title: string;
+    similarity: number;
+    commonItems: string[];
+}
+export interface SuggestedItem {
+    description: string;
+    unit: string;
+    avgUnitCost: number;
+    frequency: number;
+    reason: string;
+}
+export interface CostMetric {
+    driver: string;
+    avgCostPerUnit: number;
+    minCost: number;
+    maxCost: number;
+    sampleSize: number;
+    p90Cost: number;
+}
+/**
+ * Finds similar budgets based on item descriptions
+ */
+export declare function findSimilarBudgets(auth: AuthContext, budgetId: string): Promise<SimilarBudget[]>;
+/**
+ * Suggests items that might be missing based on similar budgets
+ */
+export declare function suggestMissingItems(auth: AuthContext, budgetId: string): Promise<SuggestedItem[]>;
+/**
+ * Calculates average cost per unit (e.g., R$/m³ de concreto)
+ */
+export declare function calculateCostPerUnit(auth: AuthContext, category: string, driver: string): Promise<CostMetric>;
+//# sourceMappingURL=analysisService.d.ts.map

package/dist/core/analysisService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysisService.d.ts","sourceRoot":"","sources":["../../src/core/analysisService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAGxC,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA+CtG;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA0DvG;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACtC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CAmDrB"}

package/dist/core/analysisService.js

@@ -0,0 +1,151 @@
+import { supabase } from './supabase.js';
+/**
+ * Finds similar budgets based on item descriptions
+ */
+export async function findSimilarBudgets(auth, budgetId) {
+    // Get target budget
+    const { data: targetBudget, error: targetError } = await supabase
+        .from('budgets')
+        .select('data')
+        .eq('id', budgetId)
+        .single();
+    if (targetError)
+        throw new Error(`Failed to get budget: ${targetError.message}`);
+    const targetRows = targetBudget?.data?.rows || [];
+    const targetDescriptions = new Set(targetRows.map(r => r.description.toLowerCase()));
+    // Get all other budgets from tenant
+    const { data: allBudgets, error: allError } = await supabase
+        .from('budgets')
+        .select('id, title, data')
+        .eq('tenant_id', auth.tenantId)
+        .eq('deleted', false)
+        .neq('id', budgetId);
+    if (allError)
+        throw new Error(`Failed to list budgets: ${allError.message}`);
+    const results = [];
+    for (const budget of allBudgets || []) {
+        const rows = budget.data?.rows || [];
+        const commonItems = [];
+        for (const row of rows) {
+            if (targetDescriptions.has(row.description.toLowerCase())) {
+                commonItems.push(row.description);
+            }
+        }
+        if (commonItems.length > 0) {
+            const similarity = Math.round((commonItems.length / Math.max(targetDescriptions.size, rows.length)) * 100);
+            results.push({
+                id: budget.id,
+                title: budget.title,
+                similarity,
+                commonItems: commonItems.slice(0, 5) // Top 5 common items
+            });
+        }
+    }
+    return results.sort((a, b) => b.similarity - a.similarity).slice(0, 10);
+}
+/**
+ * Suggests items that might be missing based on similar budgets
+ */
+export async function suggestMissingItems(auth, budgetId) {
+    // Get target budget
+    const { data: targetBudget, error: targetError } = await supabase
+        .from('budgets')
+        .select('data')
+        .eq('id', budgetId)
+        .single();
+    if (targetError)
+        throw new Error(`Failed to get budget: ${targetError.message}`);
+    const targetRows = targetBudget?.data?.rows || [];
+    const targetDescriptions = new Set(targetRows.map(r => r.description.toLowerCase()));
+    // Get all other budgets
+    const { data: allBudgets, error: allError } = await supabase
+        .from('budgets')
+        .select('data')
+        .eq('tenant_id', auth.tenantId)
+        .eq('deleted', false)
+        .neq('id', budgetId);
+    if (allError)
+        throw new Error(`Failed to list budgets: ${allError.message}`);
+    // Count frequency of items not in target
+    const itemFrequency = new Map();
+    for (const budget of allBudgets || []) {
+        const rows = budget.data?.rows || [];
+        for (const row of rows) {
+            const descLower = row.description.toLowerCase();
+            if (!targetDescriptions.has(descLower)) {
+                const existing = itemFrequency.get(descLower) || { count: 0, units: [], costs: [] };
+                existing.count++;
+                if (row.unit)
+                    existing.units.push(row.unit);
+                if (row.unitCost > 0)
+                    existing.costs.push(row.unitCost);
+                itemFrequency.set(descLower, existing);
+            }
+        }
+    }
+    // Convert to suggestions (items that appear in at least 2 budgets)
+    const suggestions = [];
+    for (const [desc, data] of itemFrequency) {
+        if (data.count >= 2) {
+            const avgCost = data.costs.length > 0
+                ? data.costs.reduce((a, b) => a + b, 0) / data.costs.length
+                : 0;
+            suggestions.push({
+                description: desc,
+                unit: data.units[0] || 'un',
+                avgUnitCost: avgCost,
+                frequency: data.count,
+                reason: `Aparece em ${data.count} orçamentos similares`
+            });
+        }
+    }
+    return suggestions.sort((a, b) => b.frequency - a.frequency).slice(0, 15);
+}
+/**
+ * Calculates average cost per unit (e.g., R$/m³ de concreto)
+ */
+export async function calculateCostPerUnit(auth, category, driver) {
+    // Get all budgets
+    const { data: allBudgets, error } = await supabase
+        .from('budgets')
+        .select('data')
+        .eq('tenant_id', auth.tenantId)
+        .eq('deleted', false);
+    if (error)
+        throw new Error(`Failed to list budgets: ${error.message}`);
+    const driverLower = driver.toLowerCase();
+    const ratios = [];
+    for (const budget of allBudgets || []) {
+        const rows = budget.data?.rows || [];
+        // Find driver item
+        const driverItem = rows.find(r => r.description.toLowerCase().includes(driverLower));
+        if (!driverItem || driverItem.quantity <= 0)
+            continue;
+        // Calculate total cost of budget
+        const totalCost = rows.reduce((sum, r) => sum + (r.quantity * r.unitCost), 0);
+        // Calculate cost per unit of driver
+        const costPerUnit = totalCost / driverItem.quantity;
+        ratios.push(costPerUnit);
+    }
+    if (ratios.length === 0) {
+        return {
+            driver,
+            avgCostPerUnit: 0,
+            minCost: 0,
+            maxCost: 0,
+            sampleSize: 0,
+            p90Cost: 0
+        };
+    }
+    ratios.sort((a, b) => a - b);
+    const avg = ratios.reduce((a, b) => a + b, 0) / ratios.length;
+    const p90Index = Math.floor(ratios.length * 0.9);
+    return {
+        driver,
+        avgCostPerUnit: Math.round(avg * 100) / 100,
+        minCost: Math.round(ratios[0] * 100) / 100,
+        maxCost: Math.round(ratios[ratios.length - 1] * 100) / 100,
+        sampleSize: ratios.length,
+        p90Cost: Math.round(ratios[p90Index] * 100) / 100
+    };
+}

package/dist/core/auth.d.ts

@@ -0,0 +1,19 @@
+export interface AuthContext {
+    userId: string;
+    tenantId: string;
+    userName: string;
+    userEmail: string;
+}
+/**
+ * Validates MCP token and returns user context
+ */
+export declare function validateToken(token: string): Promise<AuthContext>;
+/**
+ * Gets token from environment
+ */
+export declare function getTokenFromEnv(): string;
+/**
+ * Initializes auth context from env token
+ */
+export declare function initAuth(): Promise<AuthContext>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/core/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/core/auth.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,WAAW;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACrB;AAID;;GAEG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAwBvE;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAMxC;AAED;;GAEG;AACH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,WAAW,CAAC,CAGrD"}

package/dist/core/auth.js

@@ -0,0 +1,42 @@
+import { supabase } from './supabase.js';
+let cachedAuth = null;
+/**
+ * Validates MCP token and returns user context
+ */
+export async function validateToken(token) {
+    if (cachedAuth) {
+        return cachedAuth;
+    }
+    const { data, error } = await supabase.rpc('validate_mcp_token', { p_token: token });
+    if (error) {
+        throw new Error(`Token validation failed: ${error.message}`);
+    }
+    if (!data || data.length === 0) {
+        throw new Error('Invalid or expired MCP token');
+    }
+    const user = data[0];
+    cachedAuth = {
+        userId: user.user_id,
+        tenantId: user.tenant_id,
+        userName: user.user_name || 'Unknown',
+        userEmail: user.user_email || 'unknown@example.com'
+    };
+    return cachedAuth;
+}
+/**
+ * Gets token from environment
+ */
+export function getTokenFromEnv() {
+    const token = process.env.QUANTY_MCP_TOKEN;
+    if (!token) {
+        throw new Error('QUANTY_MCP_TOKEN environment variable not set');
+    }
+    return token;
+}
+/**
+ * Initializes auth context from env token
+ */
+export async function initAuth() {
+    const token = getTokenFromEnv();
+    return validateToken(token);
+}

package/dist/core/bankService.d.ts

@@ -0,0 +1,45 @@
+import { AuthContext } from './auth.js';
+export interface BankSummary {
+    id: string;
+    title: string;
+    description?: string;
+    author: string;
+    region?: string;
+    visibility: 'public' | 'private' | 'subscription';
+    categoryCount: number;
+}
+export interface BankItem {
+    id: string;
+    code: string;
+    description: string;
+    unit: string;
+    unitCost: number;
+    itemType?: string;
+}
+export interface BankCategory {
+    id: string;
+    code?: string;
+    name: string;
+    itemCount: number;
+}
+/**
+ * Lists available composition banks for the tenant
+ */
+export declare function listBanks(auth: AuthContext): Promise<BankSummary[]>;
+/**
+ * Lists categories in a bank
+ */
+export declare function getBankCategories(bankId: string): Promise<BankCategory[]>;
+/**
+ * Searches items in a bank by text
+ */
+export declare function searchBankItems(bankId: string, query: string, limit?: number): Promise<BankItem[]>;
+/**
+ * Prepares importing an item from bank to budget
+ */
+export declare function prepareImportItem(budgetId: string, bankItem: BankItem): {
+    action: string;
+    preview: string;
+    data: any;
+};
+//# sourceMappingURL=bankService.d.ts.map

package/dist/core/bankService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bankService.d.ts","sourceRoot":"","sources":["../../src/core/bankService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,QAAQ,GAAG,SAAS,GAAG,cAAc,CAAC;IAClD,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,QAAQ;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAmBzE;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAgB/E;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CA0C5G;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC7B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,QAAQ,GACnB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAchD"}

package/dist/core/bankService.js

@@ -0,0 +1,105 @@
+import { supabase } from './supabase.js';
+/**
+ * Lists available composition banks for the tenant
+ */
+export async function listBanks(auth) {
+    // Get public banks, tenant's private banks, and subscribed banks
+    const { data, error } = await supabase
+        .from('composition_banks')
+        .select('id, title, description, author_name, region, visibility, categories, tenant_id')
+        .eq('deleted', false)
+        .or(`visibility.eq.public,tenant_id.eq.${auth.tenantId}`);
+    if (error)
+        throw new Error(`Failed to list banks: ${error.message}`);
+    return (data || []).map(b => ({
+        id: b.id,
+        title: b.title,
+        description: b.description,
+        author: b.author_name || 'Unknown',
+        region: b.region,
+        visibility: b.visibility,
+        categoryCount: (b.categories || []).length
+    }));
+}
+/**
+ * Lists categories in a bank
+ */
+export async function getBankCategories(bankId) {
+    const { data, error } = await supabase
+        .from('composition_banks')
+        .select('categories')
+        .eq('id', bankId)
+        .single();
+    if (error)
+        throw new Error(`Failed to get bank: ${error.message}`);
+    const categories = data?.categories || [];
+    return categories.map((c) => ({
+        id: c.id,
+        code: c.code,
+        name: c.name,
+        itemCount: (c.items || []).length + (c.children || []).reduce((sum, child) => sum + (child.items || []).length, 0)
+    }));
+}
+/**
+ * Searches items in a bank by text
+ */
+export async function searchBankItems(bankId, query, limit = 20) {
+    const { data, error } = await supabase
+        .from('composition_banks')
+        .select('categories')
+        .eq('id', bankId)
+        .single();
+    if (error)
+        throw new Error(`Failed to search bank: ${error.message}`);
+    const results = [];
+    const queryLower = query.toLowerCase();
+    function searchInItems(items) {
+        for (const item of items) {
+            if (item.description?.toLowerCase().includes(queryLower) ||
+                item.code?.toLowerCase().includes(queryLower)) {
+                results.push({
+                    id: item.id,
+                    code: item.code,
+                    description: item.description,
+                    unit: item.unit,
+                    unitCost: item.unitCost || 0,
+                    itemType: item.itemType
+                });
+                if (results.length >= limit)
+                    return;
+            }
+            if (item.children)
+                searchInItems(item.children);
+        }
+    }
+    function searchInCategories(categories) {
+        for (const cat of categories) {
+            if (cat.items)
+                searchInItems(cat.items);
+            if (cat.children)
+                searchInCategories(cat.children);
+            if (results.length >= limit)
+                return;
+        }
+    }
+    searchInCategories(data?.categories || []);
+    return results;
+}
+/**
+ * Prepares importing an item from bank to budget
+ */
+export function prepareImportItem(budgetId, bankItem) {
+    return {
+        action: 'import_item',
+        preview: `Importar "${bankItem.description}" (${bankItem.unit}) do banco para o orçamento`,
+        data: {
+            budgetId,
+            item: {
+                description: bankItem.description,
+                unit: bankItem.unit,
+                quantity: 0, // User will fill in quantity
+                unitCost: bankItem.unitCost
+            }
+        }
+    };
+}

package/dist/core/budgetService.d.ts

@@ -0,0 +1,84 @@
+import { AuthContext } from './auth.js';
+export interface BudgetRow {
+    id: string;
+    level: number;
+    code: string;
+    description: string;
+    unit: string;
+    quantity: number;
+    unitCost: number;
+    isComposition?: boolean;
+    bdiType?: 'Principal' | 'Diferenciado';
+}
+export interface Budget {
+    id: string;
+    title: string;
+    createdAt: string;
+    lastModified: string;
+    creator: string;
+    shared: boolean;
+    projectId?: string;
+    rows: BudgetRow[];
+    bdiPrincipal: number;
+    bdiDiferenciado: number;
+}
+export interface BudgetSummary {
+    id: string;
+    title: string;
+    createdAt: string;
+    lastModified: string;
+    creator: string;
+    shared: boolean;
+    itemCount: number;
+    totalValue: number;
+}
+/**
+ * Lists recent budgets for the authenticated user's tenant or user
+ */
+export declare function listBudgets(auth: AuthContext, limit?: number): Promise<BudgetSummary[]>;
+/**
+ * Gets full budget details
+ */
+export declare function getBudget(auth: AuthContext, budgetId: string): Promise<Budget | null>;
+/**
+ * Creates a new budget (returns preview for confirmation)
+ */
+export declare function prepareCreateBudget(auth: AuthContext, title: string): {
+    action: string;
+    preview: string;
+    data: any;
+};
+/**
+ * Executes budget creation
+ */
+export declare function executeCreateBudget(auth: AuthContext, data: any): Promise<string>;
+/**
+ * Prepares adding an item to a budget
+ */
+export declare function prepareAddItem(budgetId: string, item: {
+    description: string;
+    unit: string;
+    quantity: number;
+    unitCost: number;
+}): {
+    action: string;
+    preview: string;
+    data: any;
+};
+/**
+ * Executes adding an item
+ */
+export declare function executeAddItem(auth: AuthContext, data: any): Promise<void>;
+/**
+ * Prepares item deletion
+ */
+export declare function prepareDeleteItem(budgetId: string, itemId: string, itemDescription: string): {
+    action: string;
+    preview: string;
+    data: any;
+};
+/**
+ * Executes item deletion
+ */
+export declare function executeDeleteItem(auth: AuthContext, data: any): Promise<void>;
+//# sourceMappingURL=budgetService.d.ts.map

package/dist/core/budgetService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budgetService.d.ts","sourceRoot":"","sources":["../../src/core/budgetService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,MAAM,WAAW,SAAS;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,WAAW,GAAG,cAAc,CAAC;CAC1C;AAED,MAAM,WAAW,MAAM;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA0BjG;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyB3F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAMpH;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAgCvF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC1B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAChF;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAOhD;AAED;;GAEG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BhF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAM3I;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAenF"}

package/dist/core/budgetService.js

@@ -0,0 +1,170 @@
+import { supabase } from './supabase.js';
+/**
+ * Lists recent budgets for the authenticated user's tenant or user
+ */
+export async function listBudgets(auth, limit = 10) {
+    // Query budgets by tenant_id OR user_id (for legacy budgets with null tenant_id)
+    const { data, error } = await supabase
+        .from('budgets')
+        .select('id, title, created_at, last_modified, creator, shared, data, tenant_id, user_id')
+        .or(`tenant_id.eq.${auth.tenantId},user_id.eq.${auth.userId}`)
+        .eq('deleted', false)
+        .order('last_modified', { ascending: false })
+        .limit(limit);
+    if (error)
+        throw new Error(`Failed to list budgets: ${error.message}`);
+    return (data || []).map(b => {
+        const rows = b.data?.rows || [];
+        const totalValue = rows.reduce((sum, r) => sum + (r.quantity || 0) * (r.unitCost || 0), 0);
+        return {
+            id: b.id,
+            title: b.title,
+            createdAt: b.created_at,
+            lastModified: b.last_modified,
+            creator: b.creator,
+            shared: b.shared,
+            itemCount: rows.length,
+            totalValue
+        };
+    });
+}
+/**
+ * Gets full budget details
+ */
+export async function getBudget(auth, budgetId) {
+    const { data, error } = await supabase
+        .from('budgets')
+        .select('*')
+        .eq('id', budgetId)
+        .or(`tenant_id.eq.${auth.tenantId},user_id.eq.${auth.userId}`)
+        .single();
+    if (error) {
+        if (error.code === 'PGRST116')
+            return null; // Not found
+        throw new Error(`Failed to get budget: ${error.message}`);
+    }
+    return {
+        id: data.id,
+        title: data.title,
+        createdAt: data.created_at,
+        lastModified: data.last_modified,
+        creator: data.creator,
+        shared: data.shared,
+        projectId: data.project_id,
+        rows: data.data?.rows || [],
+        bdiPrincipal: data.data?.bdiPrincipal || 0,
+        bdiDiferenciado: data.data?.bdiDiferenciado || 0
+    };
+}
+/**
+ * Creates a new budget (returns preview for confirmation)
+ */
+export function prepareCreateBudget(auth, title) {
+    return {
+        action: 'create_budget',
+        preview: `Criar orçamento "${title}"`,
+        data: { title, tenantId: auth.tenantId, userId: auth.userId, creator: auth.userName }
+    };
+}
+/**
+ * Executes budget creation
+ */
+export async function executeCreateBudget(auth, data) {
+    const now = new Date().toISOString();
+    const budgetData = {
+        title: data.title,
+        tenant_id: data.tenantId,
+        user_id: data.userId,
+        creator: data.creator,
+        created_at: now,
+        last_modified: now,
+        shared: false,
+        deleted: false,
+        data: {
+            title: data.title,
+            rows: [],
+            bdi: 0,
+            bdiItems: [],
+            bdiPrincipal: 0,
+            bdiDiferenciado: 0,
+            bdiItemsPrincipal: [],
+            bdiItemsDiferenciado: [],
+            abcClassifications: {}
+        }
+    };
+    const { data: result, error } = await supabase
+        .from('budgets')
+        .insert(budgetData)
+        .select('id')
+        .single();
+    if (error)
+        throw new Error(`Failed to create budget: ${error.message}`);
+    return result.id;
+}
+/**
+ * Prepares adding an item to a budget
+ */
+export function prepareAddItem(budgetId, item) {
+    const total = item.quantity * item.unitCost;
+    return {
+        action: 'add_item',
+        preview: `Adicionar "${item.description}" (${item.quantity} ${item.unit} x R$ ${item.unitCost.toFixed(2)} = R$ ${total.toFixed(2)})`,
+        data: { budgetId, item }
+    };
+}
+/**
+ * Executes adding an item
+ */
+export async function executeAddItem(auth, data) {
+    const budget = await getBudget(auth, data.budgetId);
+    if (!budget)
+        throw new Error('Budget not found');
+    const newRow = {
+        id: crypto.randomUUID(),
+        level: 0,
+        code: '',
+        description: data.item.description,
+        unit: data.item.unit,
+        quantity: data.item.quantity,
+        unitCost: data.item.unitCost,
+        isComposition: false
+    };
+    const updatedRows = [...budget.rows, newRow];
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: { ...budget, rows: updatedRows },
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to add item: ${error.message}`);
+}
+/**
+ * Prepares item deletion
+ */
+export function prepareDeleteItem(budgetId, itemId, itemDescription) {
+    return {
+        action: 'delete_item',
+        preview: `Excluir item "${itemDescription}"`,
+        data: { budgetId, itemId }
+    };
+}
+/**
+ * Executes item deletion
+ */
+export async function executeDeleteItem(auth, data) {
+    const budget = await getBudget(auth, data.budgetId);
+    if (!budget)
+        throw new Error('Budget not found');
+    const updatedRows = budget.rows.filter(r => r.id !== data.itemId);
+    const { error } = await supabase
+        .from('budgets')
+        .update({
+        data: { ...budget, rows: updatedRows },
+        last_modified: new Date().toISOString()
+    })
+        .eq('id', data.budgetId);
+    if (error)
+        throw new Error(`Failed to delete item: ${error.message}`);
+}

package/dist/core/supabase.d.ts

@@ -0,0 +1,5 @@
+import 'dotenv/config';
+declare const supabaseUrl = "https://aimquvsavkffqgctnzym.supabase.co";
+export declare const supabase: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;
+export { supabaseUrl };
+//# sourceMappingURL=supabase.d.ts.map

package/dist/core/supabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase.d.ts","sourceRoot":"","sources":["../../src/core/supabase.ts"],"names":[],"mappings":"AACA,OAAO,eAAe,CAAC;AAGvB,QAAA,MAAM,WAAW,6CAA6C,CAAC;AAG/D,eAAO,MAAM,QAAQ,mFAKnB,CAAC;AAEH,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/core/supabase.js

@@ -0,0 +1,12 @@
+import { createClient } from '@supabase/supabase-js';
+import 'dotenv/config';
+// Credenciais embutidas - usuário final só precisa do token MCP
+const supabaseUrl = 'https://aimquvsavkffqgctnzym.supabase.co';
+const supabaseServiceKey = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFpbXF1dnNhdmtmZnFnY3RuenltIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc2NDYzOTU3NSwiZXhwIjoyMDgwMjE1NTc1fQ.rFiSeLqIuU8SYKOzr1yLTAKgrxI2SagUyDNk1M4ouAs';
+export const supabase = createClient(supabaseUrl, supabaseServiceKey, {
+    auth: {
+        autoRefreshToken: false,
+        persistSession: false
+    }
+});
+export { supabaseUrl };

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";AAUA,OAAO,eAAe,CAAC"}

package/dist/mcp/index.js

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import 'dotenv/config';
+import { initAuth } from '../core/auth.js';
+import * as budgetService from '../core/budgetService.js';
+import * as bankService from '../core/bankService.js';
+import * as analysisService from '../core/analysisService.js';
+// Pending operations for confirmation workflow
+const pendingOperations = new Map();
+function generatePendingId() {
+    return `pending_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+// ============================================================
+// MANUAL DO QUANTY - Este conteúdo é lido automaticamente pela IA
+// ============================================================
+const QUANTY_MANUAL = `
+# Manual do Quanty - Sistema de Orçamentos de Engenharia
+
+## O que é o Quanty?
+O Quanty é um sistema de orçamentação de engenharia que permite criar, editar e analisar orçamentos de obras. 
+É usado por engenheiros civis, orçamentistas e empresas de construção.
+
+## Conceitos Importantes
+
+### 1. ORÇAMENTO
+Um orçamento contém uma lista de ITENS que representam serviços ou materiais necessários para uma obra.
+Cada orçamento tem:
+- Título
+- BDI Principal (percentual de bonificação aplicado sobre o custo)
+- BDI Diferenciado (para itens específicos como equipamentos)
+- Lista de Itens
+
+### 2. ITENS
+Cada item de um orçamento pode ser:
+
+**A) ITEM SIMPLES**: Um insumo básico (ex: "Cimento Portland 50kg")
+- Tem descrição, unidade, quantidade e custo unitário
+- O custo total = quantidade × custo unitário
+
+**B) COMPOSIÇÃO**: Um serviço composto por vários insumos (ex: "Concretagem de pilar")
+- Identificado por isComposition=true
+- Contém uma lista de INSUMOS (children) que compõem o serviço
+- O custo unitário é calculado pela SOMA dos custos dos insumos
+- Exemplo: "Concretagem" pode ter insumos: concreto, forma, ferragem, mão de obra
+
+### 3. BANCOS DE COMPOSIÇÃO
+São bases de dados com preços de referência:
+- **SINAPI**: Sistema Nacional de Pesquisa de Custos e Índices da Construção Civil (Caixa Econômica)
+- **SICRO**: Sistema de Custos de Obras Rodoviárias (DNIT)
+- **Bancos próprios**: Composições criadas pela empresa
+
+### 4. BDI (Bonificações e Despesas Indiretas)
+Percentual aplicado sobre o custo direto para cobrir:
+- Administração central
+- Lucro
+- Impostos
+- Seguros
+- Risco
+
+Preço de Venda = Custo Direto × (1 + BDI%)
+
+### 5. HIERARQUIA (NÍVEIS)
+Itens podem ser organizados em níveis hierárquicos:
+- Nível 0: Item principal (título ou agrupador)
+- Nível 1: Subitens
+- Nível 2+: Sub-subitens
+
+## Terminologia do Setor
+
+- **Insumo**: Material ou recurso básico (cimento, areia, mão de obra)
+- **Composição**: Serviço que combina vários insumos
+- **Custo Unitário**: Preço por unidade (R$/m³, R$/kg, R$/h)
+- **Quantidade**: Volume de serviço (ex: 500 m³ de concreto)
+- **EAP**: Estrutura Analítica do Projeto (organização hierárquica)
+- **Curva ABC**: Classificação de itens por impacto no custo total
+
+## Dicas para o Assistente de IA
+
+1. Quando o usuário perguntar sobre CUSTOS ZERADOS em composições, verifique se os INSUMOS (children) estão presentes
+2. Para COMPARAR preços, use a função de custo médio ou orçamentos similares
+3. Ao CRIAR itens, sempre pergunte a quantidade e verifique a unidade correta
+4. COMPOSIÇÕES devem ser importadas dos bancos (SINAPI/SICRO) para manter a estrutura
+5. O BDI padrão do mercado fica entre 20% e 30%
+`;
+// Tool definitions with detailed descriptions
+const TOOLS = [
+    // === READ TOOLS ===
+    {
+        name: 'quanty_listar_orcamentos',
+        description: `Lista os orçamentos recentes do usuário no Quanty.
+Retorna: título, data de criação/modificação, valor total estimado e quantidade de itens.
+Use esta função para descobrir quais orçamentos existem antes de abrir um específico.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limite: { type: 'number', description: 'Quantidade máxima de orçamentos (padrão: 10)' }
+            }
+        }
+    },
+    {
+        name: 'quanty_abrir_orcamento',
+        description: `Abre um orçamento e retorna todos os detalhes incluindo lista de ITENS.
+Cada item pode ser:
+- ITEM SIMPLES: tem descrição, unidade, quantidade, custo_unitario
+- COMPOSIÇÃO (is_composicao=true): serviço composto por insumos. O custo é calculado pela soma dos insumos.
+Se o custo de uma composição aparecer zerado, verifique os insumos (children) da composição.
+Use quanty_ver_composicao para ver os insumos de uma composição específica.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'ID do orçamento (obtido via quanty_listar_orcamentos)' }
+            },
+            required: ['id']
+        }
+    },
+    {
+        name: 'quanty_listar_bancos',
+        description: `Lista os bancos de composição disponíveis para buscar preços de referência.
+Bancos comuns: SINAPI (Caixa), SICRO (DNIT), ou bancos próprios da empresa.
+Use esta função antes de buscar insumos para saber qual banco usar.`,
+        inputSchema: { type: 'object', properties: {} }
+    },
+    {
+        name: 'quanty_buscar_insumo',
+        description: `Busca insumos ou composições em um banco de preços de referência.
+Retorna código, descrição, unidade e custo unitário.
+O campo 'tipo' indica se é INSUMO (material básico) ou COMPOSIÇÃO (serviço composto).
+Para importar uma composição para um orçamento, o sistema traz toda a estrutura de insumos.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                banco_id: { type: 'string', description: 'ID do banco (obtido via quanty_listar_bancos)' },
+                busca: { type: 'string', description: 'Texto para buscar (ex: "concreto fck 30", "forma metálica")' }
+            },
+            required: ['banco_id', 'busca']
+        }
+    },
+    // === WRITE TOOLS (with confirmation) ===
+    {
+        name: 'quanty_preparar_orcamento',
+        description: `Prepara a criação de um NOVO orçamento vazio.
+Retorna um preview e pending_id. Use quanty_executar para confirmar.
+O orçamento será criado com BDI zerado (pode ser ajustado depois).`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                titulo: { type: 'string', description: 'Título descritivo do orçamento (ex: "Reforma Escola Municipal")' }
+            },
+            required: ['titulo']
+        }
+    },
+    {
+        name: 'quanty_preparar_item',
+        description: `Prepara a adição de um item SIMPLES ao orçamento.
+Para adicionar COMPOSIÇÕES (serviços com insumos), use quanty_buscar_insumo + quanty_importar_composicao.
+Retorna preview e pending_id. Use quanty_executar para confirmar.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento destino' },
+                descricao: { type: 'string', description: 'Descrição do item (ex: "Demolição manual de alvenaria")' },
+                unidade: { type: 'string', description: 'Unidade de medida (m², m³, m, kg, un, h, vb)' },
+                quantidade: { type: 'number', description: 'Quantidade do serviço' },
+                custo_unitario: { type: 'number', description: 'Custo unitário em R$ (sem BDI)' }
+            },
+            required: ['orcamento_id', 'descricao', 'unidade', 'quantidade', 'custo_unitario']
+        }
+    },
+    {
+        name: 'quanty_executar',
+        description: `Confirma e executa uma operação pendente (criar orçamento, adicionar item, etc).
+Após executar, a operação é concluída e o pending_id não pode mais ser usado.
+Operações expiram após 5 minutos se não confirmadas.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pending_id: { type: 'string', description: 'ID da operação pendente (retornado por quanty_preparar_*)' }
+            },
+            required: ['pending_id']
+        }
+    },
+    // === ANALYSIS TOOLS ===
+    {
+        name: 'quanty_orcamentos_similares',
+        description: `Encontra orçamentos SIMILARES baseado nos itens em comum.
+Útil para: benchmarking, verificar se está faltando algo, comparar preços.
+Retorna lista de orçamentos ordenados por % de similaridade.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento de referência' }
+            },
+            required: ['orcamento_id']
+        }
+    },
+    {
+        name: 'quanty_sugerir_itens',
+        description: `Sugere itens que podem estar FALTANDO no orçamento.
+Analisa orçamentos similares e identifica itens frequentes que não estão presentes.
+Útil para evitar esquecimentos em obras similares.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento a analisar' }
+            },
+            required: ['orcamento_id']
+        }
+    },
+    {
+        name: 'quanty_custo_medio',
+        description: `Calcula o CUSTO MÉDIO por unidade baseado em orçamentos históricos.
+Ex: "Qual o custo médio do m³ de concreto nos meus orçamentos?"
+Retorna média, mínimo, máximo e percentil 90 (para detecção de outliers).`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                driver: { type: 'string', description: 'Item a analisar (ex: "concreto", "forma", "aço", "escavação")' },
+                categoria: { type: 'string', description: 'Categoria opcional para filtrar (ex: "fundação", "estrutura")' }
+            },
+            required: ['driver']
+        }
+    }
+];
+async function handleToolCall(auth, name, args) {
+    switch (name) {
+        // === READ ===
+        case 'quanty_listar_orcamentos': {
+            const budgets = await budgetService.listBudgets(auth, args.limite || 10);
+            return {
+                _info: 'Use quanty_abrir_orcamento com o ID para ver detalhes completos',
+                total: budgets.length,
+                orcamentos: budgets.map(b => ({
+                    id: b.id,
+                    titulo: b.title,
+                    criado_em: b.createdAt,
+                    modificado_em: b.lastModified,
+                    criador: b.creator,
+                    compartilhado: b.shared,
+                    qtd_itens: b.itemCount,
+                    valor_total: `R$ ${b.totalValue.toFixed(2)}`
+                }))
+            };
+        }
+        case 'quanty_abrir_orcamento': {
+            const budget = await budgetService.getBudget(auth, args.id);
+            if (!budget)
+                return { erro: 'Orçamento não encontrado' };
+            const totalValue = budget.rows.reduce((sum, r) => sum + (r.quantity * r.unitCost), 0);
+            return {
+                id: budget.id,
+                titulo: budget.title,
+                bdi_principal: `${budget.bdiPrincipal}%`,
+                bdi_diferenciado: `${budget.bdiDiferenciado}%`,
+                valor_total: `R$ ${totalValue.toFixed(2)}`,
+                _info_itens: 'Itens com is_composicao=true são COMPOSIÇÕES que possuem insumos internos',
+                itens: budget.rows.map(r => ({
+                    id: r.id,
+                    nivel: r.level,
+                    codigo: r.code,
+                    descricao: r.description,
+                    unidade: r.unit,
+                    quantidade: r.quantity,
+                    custo_unitario: r.unitCost,
+                    total: r.quantity * r.unitCost,
+                    is_composicao: r.isComposition || false,
+                    bdi_tipo: r.bdiType || 'Principal'
+                }))
+            };
+        }
+        case 'quanty_listar_bancos': {
+            const banks = await bankService.listBanks(auth);
+            return {
+                _info: 'Use quanty_buscar_insumo com o ID do banco para buscar itens',
+                total: banks.length,
+                bancos: banks.map(b => ({
+                    id: b.id,
+                    titulo: b.title,
+                    descricao: b.description,
+                    autor: b.author,
+                    regiao: b.region,
+                    visibilidade: b.visibility,
+                    qtd_categorias: b.categoryCount
+                }))
+            };
+        }
+        case 'quanty_buscar_insumo': {
+            const items = await bankService.searchBankItems(args.banco_id, args.busca);
+            return {
+                _info: 'Itens do tipo COMPOSIÇÃO possuem insumos internos que definem o custo',
+                total: items.length,
+                resultados: items.map(i => ({
+                    id: i.id,
+                    codigo: i.code,
+                    descricao: i.description,
+                    unidade: i.unit,
+                    custo_unitario: i.unitCost,
+                    tipo: i.itemType
+                }))
+            };
+        }
+        // === WRITE (with confirmation) ===
+        case 'quanty_preparar_orcamento': {
+            const prepared = budgetService.prepareCreateBudget(auth, args.titulo);
+            const pendingId = generatePendingId();
+            pendingOperations.set(pendingId, {
+                action: prepared.action,
+                data: prepared.data,
+                expiresAt: Date.now() + 5 * 60 * 1000
+            });
+            return {
+                pending_id: pendingId,
+                preview: prepared.preview,
+                mensagem: 'Use quanty_executar com este pending_id para confirmar a criação.'
+            };
+        }
+        case 'quanty_preparar_item': {
+            const prepared = budgetService.prepareAddItem(args.orcamento_id, {
+                description: args.descricao,
+                unit: args.unidade,
+                quantity: args.quantidade,
+                unitCost: args.custo_unitario
+            });
+            const pendingId = generatePendingId();
+            pendingOperations.set(pendingId, {
+                action: prepared.action,
+                data: prepared.data,
+                expiresAt: Date.now() + 5 * 60 * 1000
+            });
+            return {
+                pending_id: pendingId,
+                preview: prepared.preview,
+                mensagem: 'Use quanty_executar com este pending_id para confirmar a adição.'
+            };
+        }
+        case 'quanty_executar': {
+            const pending = pendingOperations.get(args.pending_id);
+            if (!pending) {
+                return { erro: 'Operação pendente não encontrada ou expirada' };
+            }
+            if (Date.now() > pending.expiresAt) {
+                pendingOperations.delete(args.pending_id);
+                return { erro: 'Operação expirada. Prepare novamente.' };
+            }
+            pendingOperations.delete(args.pending_id);
+            switch (pending.action) {
+                case 'create_budget': {
+                    const budgetId = await budgetService.executeCreateBudget(auth, pending.data);
+                    return { sucesso: true, orcamento_id: budgetId, mensagem: 'Orçamento criado com sucesso!' };
+                }
+                case 'add_item': {
+                    await budgetService.executeAddItem(auth, pending.data);
+                    return { sucesso: true, mensagem: 'Item adicionado com sucesso!' };
+                }
+                case 'import_item': {
+                    await budgetService.executeAddItem(auth, pending.data);
+                    return { sucesso: true, mensagem: 'Item importado com sucesso!' };
+                }
+                default:
+                    return { erro: `Ação desconhecida: ${pending.action}` };
+            }
+        }
+        // === ANALYSIS ===
+        case 'quanty_orcamentos_similares': {
+            const similar = await analysisService.findSimilarBudgets(auth, args.orcamento_id);
+            return {
+                total: similar.length,
+                similares: similar.map(s => ({
+                    id: s.id,
+                    titulo: s.title,
+                    similaridade: `${s.similarity}%`,
+                    itens_em_comum: s.commonItems
+                }))
+            };
+        }
+        case 'quanty_sugerir_itens': {
+            const suggestions = await analysisService.suggestMissingItems(auth, args.orcamento_id);
+            return {
+                total: suggestions.length,
+                sugestoes: suggestions.map(s => ({
+                    descricao: s.description,
+                    unidade: s.unit,
+                    custo_medio: `R$ ${s.avgUnitCost.toFixed(2)}`,
+                    frequencia: s.frequency,
+                    razao: s.reason
+                }))
+            };
+        }
+        case 'quanty_custo_medio': {
+            const metric = await analysisService.calculateCostPerUnit(auth, args.categoria || '', args.driver);
+            return {
+                driver: metric.driver,
+                custo_medio: `R$ ${metric.avgCostPerUnit.toFixed(2)}`,
+                custo_minimo: `R$ ${metric.minCost.toFixed(2)}`,
+                custo_maximo: `R$ ${metric.maxCost.toFixed(2)}`,
+                custo_p90: `R$ ${metric.p90Cost.toFixed(2)}`,
+                amostra: `${metric.sampleSize} orçamentos analisados`
+            };
+        }
+        default:
+            return { erro: `Tool não reconhecida: ${name}` };
+    }
+}
+async function main() {
+    console.error('[Quanty MCP] Starting server...');
+    // Initialize auth
+    let auth;
+    try {
+        auth = await initAuth();
+        console.error(`[Quanty MCP] Authenticated as ${auth.userName} (${auth.userEmail})`);
+    }
+    catch (error) {
+        console.error('[Quanty MCP] Auth failed:', error);
+        process.exit(1);
+    }
+    // Create MCP server with resources capability
+    const server = new Server({ name: 'quanty-mcp-server', version: '1.0.0' }, { capabilities: { tools: {}, resources: {} } });
+    // List resources handler - Manual do Quanty
+    server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+        resources: [
+            {
+                uri: 'quanty://manual',
+                name: 'Manual do Quanty',
+                description: 'Documentação completa sobre orçamentação de engenharia, conceitos, terminologia e dicas de uso.',
+                mimeType: 'text/plain'
+            }
+        ]
+    }));
+    // Read resource handler
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        if (request.params.uri === 'quanty://manual') {
+            return {
+                contents: [{ uri: 'quanty://manual', mimeType: 'text/plain', text: QUANTY_MANUAL }]
+            };
+        }
+        throw new Error(`Resource not found: ${request.params.uri}`);
+    });
+    // List tools handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOLS
+    }));
+    // Call tool handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const result = await handleToolCall(auth, name, args || {});
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ erro: error.message }) }],
+                isError: true
+            };
+        }
+    });
+    // Start server with stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[Quanty MCP] Server running on stdio');
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@quantyapp/quanty-mcp-server",
+    "version": "1.0.0",
+    "description": "MCP Server para conectar Claude Desktop ao Quanty - Sistema de Orçamentos de Engenharia",
+    "type": "module",
+    "main": "dist/mcp/index.js",
+    "bin": {
+        "quanty-mcp-server": "./dist/mcp/index.js"
+    },
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/mcp/index.js",
+        "dev": "tsx src/mcp/index.ts",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "mcp",
+        "quanty",
+        "claude",
+        "anthropic",
+        "orçamento",
+        "engenharia",
+        "construção"
+    ],
+    "author": "B2Builder",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/B2Builder-Brasil/Quanty"
+    },
+    "homepage": "https://quantyapp.com.br",
+    "engines": {
+        "node": ">=18"
+    },
+    "files": [
+        "dist/**/*"
+    ],
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "@supabase/supabase-js": "^2.39.0",
+        "dotenv": "^16.3.1",
+        "zod": "^3.22.4"
+    },
+    "devDependencies": {
+        "@types/node": "^20.10.0",
+        "tsx": "^4.7.0",
+        "typescript": "^5.3.0"
+    }
+}