@kynver-app/mcp-estimator 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kynver-app/mcp-estimator",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Kynver Estimator MCP server — chat, estimate, and catalog tools",
   "type": "module",
   "bin": {

package/src/server.ts

@@ -5,6 +5,7 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as catalogTools from "./tools/catalog-tools.js";
+import * as priceCatalogTools from "./tools/price-catalog-tools.js";
 import * as estimateTools from "./tools/estimate-tools.js";
 import * as templateTools from "./tools/template-tools.js";
 import * as versionTools from "./tools/version-tools.js";
@@ -14,6 +15,8 @@ import * as visionTools from "./tools/vision-tools.js";
 import * as companyTools from "./tools/company-tools.js";
 import * as clientTools from "./tools/client-tools.js";
 import * as takeoffTools from "./tools/takeoff-tools.js";
+import * as intakeTools from "./tools/intake-tools.js";
+import * as remodelEstimateTools from "./tools/remodel-estimate-tools.js";
 import { readOwnPackageVersion } from "./lib/package-version.js";
 
 const PACKAGE_VERSION = readOwnPackageVersion(import.meta.url);
@@ -50,6 +53,12 @@ export function createEstimatorServer(): McpServer {
   register(catalogTools.updateConfig.name, { description: catalogTools.updateConfig.description, inputSchema: catalogTools.updateConfig.inputSchemaZod }, (args) => catalogTools.updateConfig.execute(args as any));
   register(catalogTools.importTemplate.name, { description: catalogTools.importTemplate.description, inputSchema: catalogTools.importTemplate.inputSchemaZod }, (args) => catalogTools.importTemplate.execute(args as any));
 
+  // --- Price catalog tools (4) ---
+  register(priceCatalogTools.listPriceCatalogs.name, { description: priceCatalogTools.listPriceCatalogs.description, inputSchema: priceCatalogTools.listPriceCatalogs.inputSchemaZod }, (args) => priceCatalogTools.listPriceCatalogs.execute(args as any));
+  register(priceCatalogTools.getPriceCatalog.name, { description: priceCatalogTools.getPriceCatalog.description, inputSchema: priceCatalogTools.getPriceCatalog.inputSchemaZod }, (args) => priceCatalogTools.getPriceCatalog.execute(args as any));
+  register(priceCatalogTools.resolvePrice.name, { description: priceCatalogTools.resolvePrice.description, inputSchema: priceCatalogTools.resolvePrice.inputSchemaZod }, (args) => priceCatalogTools.resolvePrice.execute(args as any));
+  register(priceCatalogTools.seedPriceCatalog.name, { description: priceCatalogTools.seedPriceCatalog.description, inputSchema: priceCatalogTools.seedPriceCatalog.inputSchemaZod }, (args) => priceCatalogTools.seedPriceCatalog.execute(args as any));
+
   // --- Estimate tools (11) ---
   register(estimateTools.createReplacement.name, { description: estimateTools.createReplacement.description, inputSchema: estimateTools.createReplacement.inputSchemaZod }, (args) => estimateTools.createReplacement.execute(args as any));
   register(estimateTools.createRepair.name, { description: estimateTools.createRepair.description, inputSchema: estimateTools.createRepair.inputSchemaZod }, (args) => estimateTools.createRepair.execute(args as any));
@@ -62,6 +71,7 @@ export function createEstimatorServer(): McpServer {
   register(estimateTools.updateEstimate.name, { description: estimateTools.updateEstimate.description, inputSchema: estimateTools.updateEstimate.inputSchemaZod }, (args) => estimateTools.updateEstimate.execute(args as any));
   register(estimateTools.deleteEstimate.name, { description: estimateTools.deleteEstimate.description, inputSchema: estimateTools.deleteEstimate.inputSchemaZod }, (args) => estimateTools.deleteEstimate.execute(args as any));
   register(estimateTools.duplicateEstimate.name, { description: estimateTools.duplicateEstimate.description, inputSchema: estimateTools.duplicateEstimate.inputSchemaZod }, (args) => estimateTools.duplicateEstimate.execute(args as any));
+  register(remodelEstimateTools.buildRemodelEstimate.name, { description: remodelEstimateTools.buildRemodelEstimate.description, inputSchema: remodelEstimateTools.buildRemodelEstimate.inputSchemaZod }, (args) => remodelEstimateTools.buildRemodelEstimate.execute(args as any));
 
   // --- Template tools (4) ---
   register(templateTools.saveTemplate.name, { description: templateTools.saveTemplate.description, inputSchema: templateTools.saveTemplate.inputSchemaZod }, (args) => templateTools.saveTemplate.execute(args as any));
@@ -119,5 +129,8 @@ export function createEstimatorServer(): McpServer {
   register(takeoffTools.approveEstimate.name, { description: takeoffTools.approveEstimate.description, inputSchema: takeoffTools.approveEstimate.inputSchemaZod }, (args) => takeoffTools.approveEstimate.execute(args as any));
   register(takeoffTools.getEstimateApproval.name, { description: takeoffTools.getEstimateApproval.description, inputSchema: takeoffTools.getEstimateApproval.inputSchemaZod }, (args) => takeoffTools.getEstimateApproval.execute(args as any));
 
+  // --- Intake tools (1) ---
+  register(intakeTools.normalizeRemodelIntake.name, { description: intakeTools.normalizeRemodelIntake.description, inputSchema: intakeTools.normalizeRemodelIntake.inputSchemaZod }, (args) => intakeTools.normalizeRemodelIntake.execute(args as any));
+
   return server;
 }

package/src/tools/catalog-tools.ts

@@ -31,7 +31,7 @@ const reviewImportSchema = z.object({
       z.object({
         index: z.number(),
         action: z.enum(["keep", "skip", "edit"]),
-        edits: z.record(z.unknown()).optional(),
+        edits: z.record(z.string(), z.unknown()).optional(),
       })
     )
     .optional(),

package/src/tools/intake-tools.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import * as client from "../lib/kynver-client.js";
+
+const remodelProjectTypeSchema = z.enum([
+  "kitchen_remodel",
+  "bath_remodel",
+  "kitchen_and_bath_remodel",
+  "whole_home_remodel",
+  "other_remodel",
+]);
+
+const normalizeRemodelIntakeSchema = z.object({
+  projectType: remodelProjectTypeSchema,
+  projectName: z.string().optional(),
+  siteAddress: z.string().optional(),
+  baseScopes: z
+    .array(
+      z.object({
+        key: z.string().optional(),
+        label: z.string(),
+        quantity: z.number().optional(),
+        unit: z.string().optional(),
+        serviceCode: z.string().optional(),
+        budgetLump: z.number().optional(),
+        notes: z.string().optional(),
+        confidence: z.enum(["high", "medium", "low", "unknown"]).optional(),
+        isAlternate: z.boolean().optional(),
+        alternateGroup: z.string().optional(),
+      })
+    )
+    .optional(),
+  alternates: z
+    .array(
+      z.object({
+        key: z.string(),
+        label: z.string(),
+        scopeKeys: z.array(z.string()).optional(),
+        lumpAdd: z.number().optional(),
+        notes: z.string().optional(),
+      })
+    )
+    .optional(),
+  attachments: z
+    .array(
+      z.object({
+        id: z.string(),
+        kind: z.enum(["photo", "drawing", "plan_set", "spec_pdf", "spreadsheet", "other"]),
+        fileName: z.string().optional(),
+        caption: z.string().optional(),
+        url: z.string().optional(),
+        mimeType: z.string().optional(),
+      })
+    )
+    .optional(),
+  exclusions: z.array(z.string()).optional(),
+  surprises: z.array(z.string()).optional(),
+  rateReferences: z
+    .array(
+      z.object({
+        key: z.string(),
+        label: z.string(),
+        value: z.number(),
+        unit: z.string().optional(),
+        source: z.enum(["operating_rule", "catalog", "user", "takeoff"]),
+        catalogId: z.string().optional(),
+        confidence: z.enum(["high", "medium", "low", "unknown"]).optional(),
+      })
+    )
+    .optional(),
+  assumptionsNeedingReview: z
+    .array(
+      z.object({
+        id: z.string(),
+        text: z.string(),
+        severity: z.enum(["info", "warn", "blocker"]),
+        relatedScopeKey: z.string().optional(),
+      })
+    )
+    .optional(),
+  remodelHints: z.record(z.string(), z.unknown()).optional(),
+  includeStandardAlternates: z.boolean().optional(),
+  notes: z.string().optional(),
+});
+
+export const normalizeRemodelIntake = {
+  name: "estimator_normalize_remodel_intake",
+  description:
+    "Validate and normalize a residential remodel intake payload for kitchen/bath estimating. Accepts project type, base scopes vs alternates, drawing/photo attachment metadata, exclusions/surprises, rate references, and optional remodelHints from takeoff. Returns provenance-backed scopes, Will Portland default rates, assumptions needing review, and an estimate-builder-ready payload.",
+  inputSchemaZod: normalizeRemodelIntakeSchema,
+  execute: async (args: z.infer<typeof normalizeRemodelIntakeSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.post("/estimator/intake/normalize-remodel", args);
+    return JSON.stringify(data, null, 2);
+  },
+};

package/src/tools/price-catalog-tools.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import * as client from "../lib/kynver-client.js";
+
+const listPriceCatalogsSchema = z.object({});
+
+export const listPriceCatalogs = {
+  name: "estimator_list_price_catalogs",
+  description:
+    "List durable builtin price catalogs shipped with the estimator (region, effective date, markup policy). These are the MCP's stored price lists — not AgentOS memory. Use before seeding or resolving remodel defaults.",
+  inputSchemaZod: listPriceCatalogsSchema,
+  execute: async (_args: z.infer<typeof listPriceCatalogsSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.get("/estimator/price-catalog");
+    return JSON.stringify(data);
+  },
+};
+
+const getPriceCatalogSchema = z.object({
+  catalogId: z.string(),
+});
+
+export const getPriceCatalog = {
+  name: "estimator_get_price_catalog",
+  description:
+    "Read all unit-price lines from a builtin price catalog (service codes, units, material/labor split, review/confidence metadata). Default Portland remodel catalog id: portland-remodel-will-2026-06.",
+  inputSchemaZod: getPriceCatalogSchema,
+  execute: async (args: z.infer<typeof getPriceCatalogSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.get(`/estimator/price-catalog/${encodeURIComponent(args.catalogId)}`);
+    return JSON.stringify(data);
+  },
+};
+
+const resolvePriceSchema = z.object({
+  serviceCode: z.string(),
+  materialType: z.string().nullable().optional(),
+  region: z.string().optional(),
+  overrideMaterialCost: z.number().min(0).optional(),
+  overrideLaborCost: z.number().min(0).optional(),
+});
+
+export const resolvePrice = {
+  name: "estimator_resolve_price",
+  description:
+    "Resolve unit pricing for one service code with provenance: user price book → builtin catalog → optional intake override (overrideMaterialCost/overrideLaborCost). Returns source, region, effective date, and markupIncluded flag.",
+  inputSchemaZod: resolvePriceSchema,
+  execute: async (args: z.infer<typeof resolvePriceSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+
+    const params = new URLSearchParams({ serviceCode: args.serviceCode });
+    if (args.materialType) params.set("materialType", args.materialType);
+    if (args.region) params.set("region", args.region);
+    if (args.overrideMaterialCost != null) {
+      params.set("overrideMaterialCost", String(args.overrideMaterialCost));
+    }
+    if (args.overrideLaborCost != null) {
+      params.set("overrideLaborCost", String(args.overrideLaborCost));
+    }
+
+    const data = await client.get(`/estimator/price-catalog/resolve?${params.toString()}`);
+    return JSON.stringify(data);
+  },
+};
+
+const seedPriceCatalogSchema = z.object({
+  catalogId: z.string(),
+  overwrite: z.boolean().optional(),
+});
+
+export const seedPriceCatalog = {
+  name: "estimator_seed_price_catalog",
+  description:
+    "Copy a builtin price catalog into the user's ServiceCatalogItem price book (skips existing codes unless overwrite=true). Use portland-remodel-will-2026-06 for Will's Portland remodel working rates.",
+  inputSchemaZod: seedPriceCatalogSchema,
+  execute: async (args: z.infer<typeof seedPriceCatalogSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.post("/estimator/price-catalog/seed", args);
+    return JSON.stringify(data);
+  },
+};

package/src/tools/remodel-estimate-tools.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import * as client from "../lib/kynver-client.js";
+
+const scopeSchema = z.object({
+  key: z.string(),
+  label: z.string().optional(),
+  quantity: z.number().optional(),
+  unit: z.string().optional(),
+  serviceCode: z.string().optional(),
+  budgetLump: z.number().optional(),
+  notes: z.string().optional(),
+});
+
+const buildRemodelSchema = z.object({
+  intake: z.object({
+    projectName: z.string().optional(),
+    scopes: z.array(scopeSchema),
+    alternates: z
+      .array(
+        z.object({
+          key: z.string(),
+          label: z.string(),
+          scopeKeys: z.array(z.string()).optional(),
+          lumpAdd: z.number().optional(),
+          notes: z.string().optional(),
+        })
+      )
+      .optional(),
+    includeStandardAlternates: z.boolean().optional(),
+    exclusions: z.array(z.string()).optional(),
+    notes: z.string().optional(),
+  }),
+  takeoffRows: z
+    .array(
+      z.object({
+        id: z.string().optional(),
+        description: z.string(),
+        quantity: z.number(),
+        unit: z.string(),
+        serviceCode: z.string().nullable().optional(),
+        materialType: z.string().nullable().optional(),
+      })
+    )
+    .optional(),
+  overrides: z
+    .array(
+      z.object({
+        scopeKey: z.string().optional(),
+        serviceCode: z.string().optional(),
+        description: z.string().optional(),
+        quantity: z.number().optional(),
+        unitMaterial: z.number().optional(),
+        unitLabor: z.number().optional(),
+        lumpTotal: z.number().optional(),
+        notes: z.string().optional(),
+      })
+    )
+    .optional(),
+  pricing: z
+    .object({
+      contingencyPercent: z.number().optional(),
+      markupPercent: z.number().optional(),
+      profitPercent: z.number().optional(),
+    })
+    .optional(),
+});
+
+export const buildRemodelEstimate = {
+  name: "estimator_build_remodel_estimate",
+  description:
+    "Build a reviewable residential remodel estimate from normalized intake scopes, optional takeoff quantities, catalog prices, and overrides. Returns line items with provenance, alternates (both baths, upstairs expansion, roof, wall moving), exclusions, contingency/markup/profit breakdown, and reviewMarkdown. Does not persist — use estimator_generate_estimate_from_takeoff or estimator_create_repair after review. Scope keys: kitchen, bath_full, bath_half, bath_primary, bath_secondary, cabinets, drywall, paint, framing, roof, flooring, electrical_kitchen, electrical_bath.",
+  inputSchemaZod: buildRemodelSchema,
+  execute: async (args: z.infer<typeof buildRemodelSchema>): Promise<string> => {
+    if (!client.hasApiKey()) return client.noApiKeyMessage();
+    const data = await client.post("/estimator/estimates/build-remodel", args);
+    return JSON.stringify(data);
+  },
+};

package/src/tools/takeoff-tools.ts

@@ -13,12 +13,49 @@ const createTakeoffProjectSchema = z.object({
 
 const listTakeoffProjectsSchema = z.object({});
 
+const remodelHintsSchema = z
+  .object({
+    cabinetLinearFt: z.number().nonnegative().optional(),
+    rooms: z
+      .array(
+        z.object({
+          name: z.string(),
+          lengthFt: z.number().positive().optional(),
+          widthFt: z.number().positive().optional(),
+        })
+      )
+      .optional(),
+    baths: z
+      .array(
+        z.object({
+          type: z.enum(["full", "half", "three_quarter", "unknown"]).optional(),
+          count: z.number().int().positive().optional(),
+          label: z.string().optional(),
+        })
+      )
+      .optional(),
+    flooringSqFt: z.number().nonnegative().optional(),
+    drywallSqFt: z.number().nonnegative().optional(),
+    paintSqFt: z.number().nonnegative().optional(),
+    roofSqFt: z.number().nonnegative().optional(),
+    flags: z
+      .object({
+        wallMovingRisk: z.boolean().optional(),
+        electricalSurpriseRisk: z.boolean().optional(),
+        plumbingSurpriseRisk: z.boolean().optional(),
+      })
+      .optional(),
+    notes: z.string().optional(),
+  })
+  .optional();
+
 const uploadTakeoffInputSchema = z.object({
   projectId: z.string().uuid(),
   kind: z.string(),
   fileName: z.string(),
   base64: z.string(),
   mimeType: z.string().optional(),
+  remodelHints: remodelHintsSchema,
 });
 
 const listTakeoffRowsSchema = z.object({
@@ -119,7 +156,7 @@ export const listTakeoffProjects = {
 export const uploadTakeoffInput = {
   name: "estimator_upload_takeoff_input",
   description:
-    "Upload a takeoff input file (base64) for a project. kind: eagleview_pdf|eagleview_xml|eagleview_json|eagleview_csv|spec_pdf|spreadsheet|photo|voice|other. For remodel budgets use kind=spreadsheet with CSV.",
+    "Upload a takeoff input file (base64) for a project. kind: eagleview_pdf|eagleview_xml|eagleview_json|eagleview_csv|spec_pdf|spreadsheet|photo|voice|other. For remodel photo/drawing takeoff, use kind=photo or spec_pdf and pass optional remodelHints (cabinet LF, room dims, bath counts, flooring/drywall/paint/roof sf, risk flags) — quantities are reviewable, not auto-measured from pixels.",
   inputSchemaZod: uploadTakeoffInputSchema,
   execute: async (args: z.infer<typeof uploadTakeoffInputSchema>): Promise<string> => {
     if (!client.hasApiKey()) return client.noApiKeyMessage();
@@ -128,6 +165,7 @@ export const uploadTakeoffInput = {
       fileName: args.fileName,
       base64: args.base64,
       ...(args.mimeType ? { mimeType: args.mimeType } : {}),
+      ...(args.remodelHints ? { remodelHints: args.remodelHints } : {}),
     });
     return JSON.stringify(data);
   },