@bike4mind/cli 0.2.0 → 0.2.1-epic-lattice.16998

package/dist/{chunk-F3ETXO5N.js → chunk-WTHIDKNC.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-U3GPYBTD.js";
+} from "./chunk-HVS5VSDY.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-WR6YZRQV.js";
+} from "./chunk-RVGWNNDF.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{create-YUYXTEIS.js → create-2BFWR7P6.js}

@@ -2,10 +2,10 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-F3ETXO5N.js";
-import "./chunk-U3GPYBTD.js";
+} from "./chunk-WTHIDKNC.js";
+import "./chunk-HVS5VSDY.js";
 import "./chunk-AMDXHL6S.js";
-import "./chunk-WR6YZRQV.js";
+import "./chunk-RVGWNNDF.js";
 import "./chunk-PDX44BCA.js";
 export {
   createFabFile,

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-QXGU6KYI.js";
-import "./chunk-LZMRYJ3B.js";
-import "./chunk-F3ETXO5N.js";
+} from "./chunk-RAG4OWCW.js";
+import "./chunk-CVF7NYCS.js";
+import "./chunk-WTHIDKNC.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,7 +15,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-U3GPYBTD.js";
+} from "./chunk-HVS5VSDY.js";
 import {
   Logger
 } from "./chunk-AMDXHL6S.js";
@@ -72,7 +72,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-WR6YZRQV.js";
+} from "./chunk-RVGWNNDF.js";
 import {
   __require
 } from "./chunk-PDX44BCA.js";
@@ -7238,6 +7238,461 @@ var deleteFileTool = {
   })
 };
 
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/lattice/index.js
+var latticeCreateModelTool = {
+  name: "lattice_create_model",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { name, description, modelType = "custom" } = params;
+      const modelId = `lattice_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      return JSON.stringify({
+        success: true,
+        action: "CREATE_MODEL",
+        modelId,
+        data: {
+          name,
+          description,
+          modelType
+        },
+        message: `Created new ${modelType} model "${name}" with ID ${modelId}. You can now add entities and rules to this model.`
+      });
+    },
+    toolSchema: {
+      name: "lattice_create_model",
+      description: `Create a new Lattice financial model. This is the first step when building a pro-forma or financial analysis.
+
+**When to use:** When the user wants to:
+- Create a new financial model, spreadsheet, or pro-forma
+- Start building an income statement, balance sheet, or cash flow
+- Set up a SaaS metrics dashboard
+- Begin any structured numerical analysis
+
+**Model types:**
+- income_statement: P&L with revenue, expenses, profits
+- balance_sheet: Assets, liabilities, equity
+- cashflow: Operating, investing, financing cash flows
+- saas_metrics: MRR, ARR, churn, CAC, LTV
+- custom: Any other structured model
+
+After creating a model, add entities with \`lattice_add_entity\` and define formulas with \`lattice_create_rule\`.`,
+      parameters: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: 'Name of the model (e.g., "2024 Budget", "Q1 Forecast")'
+          },
+          description: {
+            type: "string",
+            description: "Optional description of what this model represents"
+          },
+          modelType: {
+            type: "string",
+            enum: ["income_statement", "balance_sheet", "cashflow", "saas_metrics", "custom"],
+            description: "Type of financial model to create"
+          }
+        },
+        required: ["name"]
+      }
+    }
+  })
+};
+var latticeAddEntityTool = {
+  name: "lattice_add_entity",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { modelId, name, type, displayName, initialValues = [] } = params;
+      const entityId = name.toLowerCase().replace(/\s+/g, "_");
+      return JSON.stringify({
+        success: true,
+        action: "ADD_ENTITY",
+        modelId,
+        entityId,
+        data: {
+          name,
+          type,
+          displayName: displayName || name,
+          attributes: initialValues.map((v) => ({
+            key: v.key,
+            value: v.value,
+            dataType: v.dataType || (typeof v.value === "number" ? "number" : "string"),
+            isComputed: false
+          }))
+        },
+        message: `Added ${type} "${displayName || name}" to model. ${initialValues.length > 0 ? `Set initial values: ${initialValues.map((v) => `${v.key}=${v.value}`).join(", ")}` : "No initial values set."}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_add_entity",
+      description: `Add a line item, account, period, or other entity to a Lattice model.
+
+**When to use:** When the user mentions:
+- Adding a revenue line, expense category, or account
+- Creating periods (Q1, Q2, Jan, Feb, etc.)
+- Adding any measurable item to their model
+
+**Entity types:**
+- line_item: Revenue streams, expense lines, KPIs
+- account: Cash, AR, AP, inventory, etc.
+- period: Q1 2024, Jan, FY2025, etc.
+- category: Groups of line items (Operating Expenses)
+- scenario: Base case, upside, downside
+- custom: Any other structured element
+
+**Examples:**
+- "Add Revenue" \u2192 line_item named "Revenue"
+- "Create a Marketing Expenses category" \u2192 category named "Marketing Expenses"
+- "Add quarters Q1 through Q4" \u2192 4 period entities`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model to add the entity to"
+          },
+          name: {
+            type: "string",
+            description: "Internal name for the entity (used in formulas)"
+          },
+          type: {
+            type: "string",
+            enum: ["line_item", "account", "period", "category", "scenario", "custom"],
+            description: "Type of entity"
+          },
+          displayName: {
+            type: "string",
+            description: "Human-readable display name (defaults to name)"
+          },
+          initialValues: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                key: { type: "string", description: 'Period or attribute key (e.g., "Q1_2024")' },
+                value: { type: "string", description: "The value (number or string)" },
+                dataType: {
+                  type: "string",
+                  enum: ["number", "currency", "percentage", "string"],
+                  description: "Data type for the value"
+                }
+              },
+              required: ["key", "value"]
+            },
+            description: "Optional initial values for this entity"
+          }
+        },
+        required: ["modelId", "name", "type"]
+      }
+    }
+  })
+};
+var latticeSetValueTool = {
+  name: "lattice_set_value",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { modelId, entityName, attributeKey, value: rawValue } = params;
+      let value = rawValue;
+      const numValue = parseFloat(rawValue);
+      if (!isNaN(numValue)) {
+        value = numValue;
+      } else if (rawValue.toLowerCase() === "true") {
+        value = true;
+      } else if (rawValue.toLowerCase() === "false") {
+        value = false;
+      }
+      return JSON.stringify({
+        success: true,
+        action: "SET_VALUE",
+        modelId,
+        data: {
+          entityName,
+          attributeKey,
+          value
+        },
+        message: `Set ${entityName}.${attributeKey} = ${value}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_set_value",
+      description: `Set a specific value in a Lattice model.
+
+**When to use:** When the user provides a specific number:
+- "Revenue in Q1 is 150,000"
+- "Set marketing spend to 50k for January"
+- "COGS is 40% of revenue" (use lattice_create_rule for formulas)
+
+**Important:** This tool is for setting raw input values. For calculated values (formulas), use \`lattice_create_rule\` instead.
+
+**Examples:**
+- "Q1 revenue is $100,000" \u2192 entityName="Revenue", attributeKey="Q1", value=100000
+- "Set headcount to 25" \u2192 entityName="Headcount", attributeKey="current", value=25`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model"
+          },
+          entityName: {
+            type: "string",
+            description: "Name of the entity (line item, account, etc.)"
+          },
+          attributeKey: {
+            type: "string",
+            description: 'Period or attribute key (e.g., "Q1_2024", "current", "budget")'
+          },
+          value: {
+            type: "string",
+            description: "The value to set (will be parsed as number if numeric)"
+          }
+        },
+        required: ["modelId", "entityName", "attributeKey", "value"]
+      }
+    }
+  })
+};
+var latticeCreateRuleTool = {
+  name: "lattice_create_rule",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { modelId, name, description, formula } = params;
+      const parsedRule = parseFormula(formula);
+      return JSON.stringify({
+        success: true,
+        action: "CREATE_RULE",
+        modelId,
+        ruleId: `rule_${Date.now()}`,
+        data: {
+          name,
+          description,
+          formula,
+          parsed: parsedRule
+        },
+        message: `Created rule "${name}": ${formula}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_create_rule",
+      description: `Create a formula or calculation rule in a Lattice model.
+
+**When to use:** When the user defines a calculation:
+- "Gross profit equals revenue minus COGS"
+- "Net margin is net income divided by revenue times 100"
+- "Total expenses is the sum of all expense line items"
+
+**Formula syntax (natural language):**
+- Arithmetic: "X equals Y plus Z", "A minus B", "C times D"
+- Aggregation: "sum of", "average of", "total"
+- Percentage: "X percent of Y", "as a percentage"
+- Comparison: "if X is greater than Y then A else B"
+
+**Examples:**
+- "Gross Profit = Revenue - COGS"
+- "Gross Margin = Gross Profit / Revenue * 100"
+- "Total OpEx = sum of all Operating Expenses"
+- "YoY Growth = (Current Year - Prior Year) / Prior Year * 100"`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model"
+          },
+          name: {
+            type: "string",
+            description: 'Name for this rule (e.g., "Gross Profit Calculation")'
+          },
+          description: {
+            type: "string",
+            description: "Optional description of what this rule calculates"
+          },
+          formula: {
+            type: "string",
+            description: "The formula in natural language or equation format"
+          }
+        },
+        required: ["modelId", "name", "formula"]
+      }
+    }
+  })
+};
+var latticeQueryTool = {
+  name: "lattice_query",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { modelId, query } = params;
+      const parsedQuery = parseQuery(query);
+      return JSON.stringify({
+        success: true,
+        action: "QUERY",
+        modelId,
+        data: {
+          query,
+          parsed: parsedQuery
+        },
+        message: `Querying model for: ${query}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_query",
+      description: `Query a Lattice model for specific values or aggregations.
+
+**When to use:** When the user asks about values in the model:
+- "What's Q1 gross margin?"
+- "Show me total revenue for 2024"
+- "What are all the expense categories?"
+- "Compare Q1 vs Q2 performance"
+
+**Query types:**
+- Single value: "What is [entity] for [period]?"
+- Aggregation: "Total [entity] for [range]"
+- Comparison: "Compare [entity] across [periods]"
+- List: "Show all [entity type]"
+
+**Examples:**
+- "What's Q2 revenue?" \u2192 Returns specific value
+- "Total revenue for 2024" \u2192 Sums Q1-Q4
+- "Compare gross margin Q1 vs Q2" \u2192 Side-by-side comparison`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model to query"
+          },
+          query: {
+            type: "string",
+            description: "Natural language query about the model"
+          }
+        },
+        required: ["modelId", "query"]
+      }
+    }
+  })
+};
+var latticeExplainTool = {
+  name: "lattice_explain",
+  implementation: () => ({
+    toolFn: async (params) => {
+      const { modelId, entityName, attributeKey } = params;
+      return JSON.stringify({
+        success: true,
+        action: "EXPLAIN",
+        modelId,
+        data: {
+          entityName,
+          attributeKey
+        },
+        message: `Explaining calculation for ${entityName}.${attributeKey}`
+      });
+    },
+    toolSchema: {
+      name: "lattice_explain",
+      description: `Explain how a value in a Lattice model was calculated.
+
+**When to use:** When the user wants to understand a calculation:
+- "How did you calculate gross profit?"
+- "Explain the Q2 margin number"
+- "Show me the formula for total expenses"
+- "Why is this number so high?"
+
+This tool traces the calculation chain from the target value back through all its inputs and rules, providing a step-by-step explanation.`,
+      parameters: {
+        type: "object",
+        properties: {
+          modelId: {
+            type: "string",
+            description: "ID of the model"
+          },
+          entityName: {
+            type: "string",
+            description: "Name of the entity containing the value to explain"
+          },
+          attributeKey: {
+            type: "string",
+            description: "Period or attribute key of the value to explain"
+          }
+        },
+        required: ["modelId", "entityName", "attributeKey"]
+      }
+    }
+  })
+};
+function parseFormula(formula) {
+  const normalized = formula.toLowerCase().trim();
+  const equalsMatch = normalized.match(/^(\w+)\s*(?:=|equals?)\s*(.+)$/i);
+  if (equalsMatch) {
+    const [, output, expression] = equalsMatch;
+    if (expression.includes("+") || expression.includes("plus")) {
+      return {
+        operation: "ADD",
+        outputEntity: output,
+        inputs: expression.split(/[+]|plus/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("-") || expression.includes("minus")) {
+      return {
+        operation: "SUBTRACT",
+        outputEntity: output,
+        inputs: expression.split(/[-]|minus/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("*") || expression.includes("times") || expression.includes("x")) {
+      return {
+        operation: "MULTIPLY",
+        outputEntity: output,
+        inputs: expression.split(/[*x]|times/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("/") || expression.includes("divided")) {
+      return {
+        operation: "DIVIDE",
+        outputEntity: output,
+        inputs: expression.split(/[/]|divided by/i).map((s) => s.trim())
+      };
+    }
+    if (expression.includes("sum")) {
+      return {
+        operation: "SUM",
+        outputEntity: output,
+        inputs: [expression.replace(/sum of/i, "").trim()]
+      };
+    }
+  }
+  return {
+    operation: "REFERENCE",
+    outputEntity: "unknown",
+    inputs: [formula]
+  };
+}
+function parseQuery(query) {
+  const normalized = query.toLowerCase();
+  let type = "single_value";
+  if (normalized.includes("total") || normalized.includes("sum")) {
+    type = "aggregation";
+  } else if (normalized.includes("compare") || normalized.includes("vs")) {
+    type = "comparison";
+  } else if (normalized.includes("list") || normalized.includes("show all")) {
+    type = "list";
+  }
+  const entities = [];
+  const periods = [];
+  const periodPatterns = [/q[1-4]/gi, /\d{4}/g, /jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/gi];
+  for (const pattern of periodPatterns) {
+    const matches = query.match(pattern);
+    if (matches) {
+      periods.push(...matches);
+    }
+  }
+  const commonEntities = ["revenue", "expenses", "profit", "margin", "income", "cost", "cogs", "ebitda"];
+  for (const entity of commonEntities) {
+    if (normalized.includes(entity)) {
+      entities.push(entity);
+    }
+  }
+  return { type, entities, periods };
+}
+
 // ../../b4m-core/packages/services/dist/src/llm/tools/index.js
 var tools = {
   dice_roll: diceRollTool,
@@ -7265,7 +7720,14 @@ var tools = {
   create_file: createFileTool,
   glob_files: globFilesTool,
   grep_search: grepSearchTool,
-  delete_file: deleteFileTool
+  delete_file: deleteFileTool,
+  // Lattice financial modeling tools
+  lattice_create_model: latticeCreateModelTool,
+  lattice_add_entity: latticeAddEntityTool,
+  lattice_set_value: latticeSetValueTool,
+  lattice_create_rule: latticeCreateRuleTool,
+  lattice_query: latticeQueryTool,
+  lattice_explain: latticeExplainTool
 };
 var generateTools = (userId, user, logger2, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model) => {
   const context = {
@@ -8758,7 +9220,7 @@ var ApiClient = class {
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.0",
+  version: "0.2.1-epic-lattice.16998+1c9b90db0",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -8854,11 +9316,11 @@ var package_default = {
     zustand: "^4.5.4"
   },
   devDependencies: {
-    "@bike4mind/agents": "workspace:*",
-    "@bike4mind/common": "workspace:*",
-    "@bike4mind/mcp": "workspace:*",
-    "@bike4mind/services": "workspace:*",
-    "@bike4mind/utils": "workspace:*",
+    "@bike4mind/agents": "0.1.0",
+    "@bike4mind/common": "2.36.1-epic-lattice.16998+1c9b90db0",
+    "@bike4mind/mcp": "1.19.4-epic-lattice.16998+1c9b90db0",
+    "@bike4mind/services": "2.29.1-epic-lattice.16998+1c9b90db0",
+    "@bike4mind/utils": "2.0.3-epic-lattice.16998+1c9b90db0",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -8868,7 +9330,8 @@ var package_default = {
     tsup: "^8.5.1",
     tsx: "^4.21.0",
     typescript: "^5.9.3"
-  }
+  },
+  gitHead: "1c9b90db0a9c1960d484fb1a3cea7608cd339946"
 };
 
 // src/index.tsx

package/dist/{llmMarkdownGenerator-4ZR3FLEQ.js → llmMarkdownGenerator-ZLW7KP6R.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-WR6YZRQV.js";
+} from "./chunk-RVGWNNDF.js";
 import "./chunk-PDX44BCA.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/llmMarkdownGenerator.js

package/dist/{markdownGenerator-7WE7WKME.js → markdownGenerator-OTSVN5CO.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-WR6YZRQV.js";
+} from "./chunk-RVGWNNDF.js";
 import "./chunk-PDX44BCA.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/markdownGenerator.js

package/dist/{mementoService-2BDIT6PH.js → mementoService-4MR3S6PT.js}

@@ -2,10 +2,10 @@
 import {
   findMostSimilarMemento,
   getRelevantMementos
-} from "./chunk-QXGU6KYI.js";
-import "./chunk-U3GPYBTD.js";
+} from "./chunk-RAG4OWCW.js";
+import "./chunk-HVS5VSDY.js";
 import "./chunk-AMDXHL6S.js";
-import "./chunk-WR6YZRQV.js";
+import "./chunk-RVGWNNDF.js";
 import "./chunk-PDX44BCA.js";
 export {
   findMostSimilarMemento,