@bike4mind/cli 0.2.1-epic-lattice.17015 → 0.2.1-feat-cli-usage-command.16999

package/dist/index.js

@@ -4,10 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-GSXZOOWP.js";
-import "./chunk-NHP3UPYU.js";
-import "./chunk-FMXGH4KC.js";
-import "./chunk-HHHI5KKC.js";
+} from "./chunk-QXGU6KYI.js";
+import "./chunk-LZMRYJ3B.js";
+import "./chunk-F3ETXO5N.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -16,7 +15,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-7JFN4F7V.js";
+} from "./chunk-U3GPYBTD.js";
 import {
   Logger
 } from "./chunk-AMDXHL6S.js";
@@ -30,6 +29,7 @@ import {
   AuthEvents,
   BFL_IMAGE_MODELS,
   BFL_SAFETY_TOLERANCE,
+  CREDIT_DEDUCT_TRANSACTION_TYPES,
   ChatCompletionCreateInputSchema,
   ChatModels,
   CollectionType,
@@ -73,7 +73,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-ZMZK7YVU.js";
+} from "./chunk-WR6YZRQV.js";
 import {
   __require
 } from "./chunk-PDX44BCA.js";
@@ -178,6 +178,10 @@ var COMMANDS = [
   {
     name: "trusted",
     description: "List all trusted tools"
+  },
+  {
+    name: "usage",
+    description: "Show credit usage and balance"
   }
 ];
 
@@ -7239,632 +7243,6 @@ var deleteFileTool = {
   })
 };
 
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/lattice/index.js
-function createModelData(name, modelType, userId, description, sessionId) {
-  const now = /* @__PURE__ */ new Date();
-  return {
-    name,
-    description: description || "",
-    modelType,
-    userId,
-    sessionId,
-    data: { entities: [], relationships: [] },
-    rules: { rules: [], rulesets: [] },
-    views: { views: [] },
-    settings: {
-      currency: "USD",
-      fiscalYearStart: "01-01",
-      periodGrain: "quarter",
-      defaultDecimalPlaces: 2,
-      negativeFormat: "parentheses"
-    },
-    scenarios: [],
-    operations: [],
-    operationIndex: -1,
-    version: 1,
-    createdAt: now,
-    updatedAt: now
-  };
-}
-var latticeCreateModelTool = {
-  name: "lattice_create_model",
-  implementation: (context) => ({
-    toolFn: async (params) => {
-      const { name, description, modelType = "custom" } = params;
-      const modelData = createModelData(name, modelType, context.userId, description);
-      let model;
-      if (context.db.latticeModels) {
-        try {
-          model = await context.db.latticeModels.create(modelData);
-          context.logger.info(`[Lattice] Created model ${model.id} in database`);
-        } catch (error) {
-          context.logger.error(`[Lattice] Failed to persist model to database:`, error);
-          model = {
-            ...modelData,
-            id: `lattice_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-          };
-        }
-      } else {
-        context.logger.warn("[Lattice] No database adapter available, creating in-memory model");
-        model = {
-          ...modelData,
-          id: `lattice_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-        };
-      }
-      const artifactData = {
-        type: "lattice",
-        id: model.id,
-        title: name,
-        content: JSON.stringify(model),
-        metadata: {
-          modelType,
-          periodGrain: model.settings?.periodGrain || "quarter",
-          currency: model.settings?.currency || "USD",
-          entityCount: model.data?.entities?.length || 0,
-          ruleCount: model.rules?.rules?.length || 0
-        },
-        createdAt: model.createdAt?.toISOString?.() || (/* @__PURE__ */ new Date()).toISOString(),
-        updatedAt: model.updatedAt?.toISOString?.() || (/* @__PURE__ */ new Date()).toISOString()
-      };
-      return `I've created a new ${modelType} financial model called "${name}".
-
-<artifact identifier="${model.id}" type="application/vnd.b4m.lattice" title="${name}">
-${JSON.stringify(artifactData, null, 2)}
-</artifact>
-
-You can now add line items, set values, and create formulas. Try saying:
-- "Add Revenue and COGS line items"
-- "Set Q1 Revenue to 100,000"
-- "Gross Profit equals Revenue minus COGS"`;
-    },
-    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: (context) => ({
-    toolFn: async (params) => {
-      const { modelId, name, type, displayName, initialValues = [] } = params;
-      const entityId = name.toLowerCase().replace(/\s+/g, "_");
-      const entityData = {
-        id: entityId,
-        type,
-        name,
-        displayName: displayName || name,
-        attributes: initialValues.map((v) => ({
-          key: v.key,
-          value: v.value,
-          dataType: v.dataType || (typeof v.value === "number" ? "number" : "string"),
-          isComputed: false
-        })),
-        metadata: {},
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) {
-        try {
-          const model = await context.db.latticeModels.findById(modelId);
-          if (model) {
-            const existingIndex = model.data.entities.findIndex((e) => e.id === entityId);
-            if (existingIndex >= 0) {
-              model.data.entities[existingIndex] = entityData;
-            } else {
-              model.data.entities.push(entityData);
-            }
-            await context.db.latticeModels.update({
-              id: modelId,
-              data: model.data,
-              updatedAt: /* @__PURE__ */ new Date()
-            });
-            context.logger.info(`[Lattice] Added entity ${entityId} to model ${modelId}`);
-          } else {
-            context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
-          }
-        } catch (error) {
-          context.logger.error(`[Lattice] Failed to persist entity to database:`, error);
-        }
-      }
-      return JSON.stringify({
-        success: true,
-        action: "ADD_ENTITY",
-        modelId,
-        entityId,
-        data: entityData,
-        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: (context) => ({
-    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;
-      }
-      const entityId = entityName.toLowerCase().replace(/\s+/g, "_");
-      if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) {
-        try {
-          const model = await context.db.latticeModels.findById(modelId);
-          if (model) {
-            const entity = model.data.entities.find((e) => e.id === entityId || e.name === entityName);
-            if (entity) {
-              const attrIndex = entity.attributes.findIndex((a) => a.key === attributeKey);
-              const dataType = typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "string";
-              const attributeData = {
-                key: attributeKey,
-                value,
-                dataType,
-                isComputed: false
-              };
-              if (attrIndex >= 0) {
-                entity.attributes[attrIndex] = attributeData;
-              } else {
-                entity.attributes.push(attributeData);
-              }
-              entity.updatedAt = /* @__PURE__ */ new Date();
-              await context.db.latticeModels.update({
-                id: modelId,
-                data: model.data,
-                updatedAt: /* @__PURE__ */ new Date()
-              });
-              context.logger.info(`[Lattice] Set ${entityId}.${attributeKey} = ${value} in model ${modelId}`);
-            } else {
-              context.logger.warn(`[Lattice] Entity ${entityName} not found in model ${modelId}`);
-            }
-          } else {
-            context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
-          }
-        } catch (error) {
-          context.logger.error(`[Lattice] Failed to persist value to database:`, error);
-        }
-      }
-      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: (context) => ({
-    toolFn: async (params) => {
-      const { modelId, name, description, formula } = params;
-      const parsedRule = parseFormula(formula);
-      const ruleId = `rule_${Date.now()}`;
-      const ruleData = {
-        id: ruleId,
-        name,
-        description: description || formula,
-        type: "formula",
-        definition: {
-          operation: parsedRule.operation,
-          inputs: parsedRule.inputs.map((ref) => ({
-            type: "entity",
-            ref
-          })),
-          output: {
-            targetEntityId: parsedRule.outputEntity.toLowerCase().replace(/\s+/g, "_"),
-            targetAttribute: "computed",
-            dataType: "number"
-          }
-        },
-        dependencies: parsedRule.inputs.map((i) => i.toLowerCase().replace(/\s+/g, "_")),
-        priority: 0,
-        enabled: true,
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      if (context.db.latticeModels && modelId && /^[a-f0-9]{24}$/.test(modelId)) {
-        try {
-          const model = await context.db.latticeModels.findById(modelId);
-          if (model) {
-            const existingIndex = model.rules.rules.findIndex((r) => r.id === ruleId || r.name === name);
-            if (existingIndex >= 0) {
-              model.rules.rules[existingIndex] = ruleData;
-            } else {
-              model.rules.rules.push(ruleData);
-            }
-            await context.db.latticeModels.update({
-              id: modelId,
-              rules: model.rules,
-              updatedAt: /* @__PURE__ */ new Date()
-            });
-            context.logger.info(`[Lattice] Created rule ${ruleId} in model ${modelId}`);
-          } else {
-            context.logger.warn(`[Lattice] Model ${modelId} not found in database`);
-          }
-        } catch (error) {
-          context.logger.error(`[Lattice] Failed to persist rule to database:`, error);
-        }
-      }
-      return JSON.stringify({
-        success: true,
-        action: "CREATE_RULE",
-        modelId,
-        ruleId,
-        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,
@@ -7892,14 +7270,7 @@ var tools = {
   create_file: createFileTool,
   glob_files: globFilesTool,
   grep_search: grepSearchTool,
-  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
+  delete_file: deleteFileTool
 };
 var generateTools = (userId, user, logger2, { db }, storage, imageGenerateStorage, statusUpdate, onStart, onFinish, llm, config, model) => {
   const context = {
@@ -8029,7 +7400,6 @@ var QuestStartBodySchema = z137.object({
   enableMementos: z137.boolean().optional(),
   enableArtifacts: z137.boolean().optional(),
   enableAgents: z137.boolean().optional(),
-  enableLattice: z137.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
   tools: z137.array(z137.union([b4mLLMTools, z137.string()])).optional(),
   mcpServers: z137.array(z137.string()).optional(),
@@ -9390,10 +8760,13 @@ var ApiClient = class {
   }
 };
 
+// src/index.tsx
+import { isAxiosError as isAxiosError2 } from "axios";
+
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.1-epic-lattice.17015+ef53d52c1",
+  version: "0.2.1-feat-cli-usage-command.16999+815cdcd08",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -9490,10 +8863,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.36.1-epic-lattice.17015+ef53d52c1",
-    "@bike4mind/mcp": "1.19.4-epic-lattice.17015+ef53d52c1",
-    "@bike4mind/services": "2.29.1-epic-lattice.17015+ef53d52c1",
-    "@bike4mind/utils": "2.0.3-epic-lattice.17015+ef53d52c1",
+    "@bike4mind/common": "2.36.1-feat-cli-usage-command.16999+815cdcd08",
+    "@bike4mind/mcp": "1.19.4-feat-cli-usage-command.16999+815cdcd08",
+    "@bike4mind/services": "2.29.1-feat-cli-usage-command.16999+815cdcd08",
+    "@bike4mind/utils": "2.0.3-feat-cli-usage-command.16999+815cdcd08",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -9504,9 +8877,14 @@ var package_default = {
     tsx: "^4.21.0",
     typescript: "^5.9.3"
   },
-  gitHead: "ef53d52c1d52fff50c780e7ae56cc814e38c030f"
+  gitHead: "815cdcd0897c92e3713ce3e04c930b70332cb318"
 };
 
+// src/config/constants.ts
+var USAGE_DAYS = 30;
+var MODEL_NAME_COLUMN_WIDTH = 18;
+var USAGE_CACHE_TTL = 5 * 60 * 1e3;
+
 // src/index.tsx
 process.removeAllListeners("warning");
 process.on("warning", (warning) => {
@@ -9517,6 +8895,7 @@ process.on("warning", (warning) => {
 });
 var exitTimestamp = null;
 var EXIT_TIMEOUT_MS = 2e3;
+var usageCache = null;
 function CliApp() {
   const { exit } = useApp();
   const [state, setState] = useState3({
@@ -9881,6 +9260,7 @@ Available commands:
   /login - Authenticate with your B4M account
   /logout - Clear authentication and sign out
   /whoami - Show current authenticated user
+  /usage - Show credit usage and balance
   /save <name> - Save current session
   /sessions - List saved sessions
   /config - Show configuration
@@ -10051,6 +9431,103 @@ Tool Permissions:
         console.log(`Expires: ${new Date(authTokens.expiresAt).toLocaleString()}`);
         console.log("");
         break;
+      case "usage": {
+        const usageAuthTokens = await state.configStore.getAuthTokens();
+        if (!usageAuthTokens || new Date(usageAuthTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
+          console.log("\nNot authenticated. Run /login to authenticate.\n");
+          return;
+        }
+        console.log("\nFetching usage data...");
+        const now = Date.now();
+        let currentCredits;
+        let transactions;
+        if (usageCache && now - usageCache.timestamp < USAGE_CACHE_TTL) {
+          currentCredits = usageCache.data.currentCredits;
+          transactions = usageCache.data.transactions;
+          console.log("(using cached data)\n");
+        } else {
+          try {
+            const config = await state.configStore.get();
+            const apiBaseURL = getApiUrl(config.apiConfig);
+            const apiClient = new ApiClient(apiBaseURL, state.configStore);
+            const [identifyResponse, transactionsResponse] = await Promise.all([
+              apiClient.get("/api/identify"),
+              apiClient.get(`/api/credits/transactions?days=${USAGE_DAYS}`)
+            ]);
+            currentCredits = identifyResponse.user.currentCredits;
+            transactions = transactionsResponse || [];
+            usageCache = {
+              data: { currentCredits, transactions },
+              timestamp: now
+            };
+          } catch (error) {
+            if (isAxiosError2(error)) {
+              if (error.response?.status === 401) {
+                console.log("\n\u274C Authentication failed. Run /login to re-authenticate.\n");
+              } else if (error.response?.status === 403) {
+                console.log("\n\u274C Access denied. You may not have permission to view usage data.\n");
+              } else if (error.response?.status === 404) {
+                console.log("\n\u274C Usage endpoint not available on this server.\n");
+              } else if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+                console.log("\n\u274C Cannot connect to server. Check your API configuration with /api-info\n");
+              } else {
+                console.log(`
+\u274C Error fetching usage data: ${error.message}
+`);
+              }
+            } else if (error instanceof Error) {
+              console.log(`
+\u274C Error: ${error.message}
+`);
+            } else {
+              console.log("\n\u274C Unexpected error fetching usage data. Please try again.\n");
+            }
+            break;
+          }
+        }
+        const deductTransactions = transactions.filter(
+          (t) => CREDIT_DEDUCT_TRANSACTION_TYPES.includes(t.type)
+        );
+        const totalCreditsUsed = deductTransactions.reduce((sum2, t) => sum2 + Math.abs(t.credits), 0);
+        const dailyBurnRate = Math.round(totalCreditsUsed / USAGE_DAYS);
+        let daysRemainingStr;
+        if (dailyBurnRate === 0) {
+          daysRemainingStr = "N/A (no usage)";
+        } else {
+          const daysRemaining = Math.floor(currentCredits / dailyBurnRate);
+          daysRemainingStr = `~${daysRemaining.toLocaleString()} days`;
+        }
+        const usageByModel = {};
+        for (const t of deductTransactions) {
+          const modelName = t.metadata?.modelName || ("model" in t ? t.model : null) || "Unknown";
+          usageByModel[modelName] = (usageByModel[modelName] || 0) + Math.abs(t.credits);
+        }
+        const sortedModels = Object.entries(usageByModel).sort((a, b) => b[1] - a[1]);
+        console.log("\n Credit Usage Summary");
+        console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+        console.log(`Credits Balance:    ${currentCredits.toLocaleString()}`);
+        console.log(`Daily Burn Rate:    ${dailyBurnRate.toLocaleString()} credits/day`);
+        console.log(`Days Remaining:     ${daysRemainingStr}`);
+        if (currentCredits === 0) {
+          console.log("\n\u26A0\uFE0F  You have no credits remaining.");
+          console.log("\u{1F4A1} Visit bike4mind.io to purchase more credits.\n");
+          break;
+        }
+        if (sortedModels.length > 0) {
+          console.log(`
+Usage by Model (Last ${USAGE_DAYS} days):`);
+          for (const [model, credits] of sortedModels) {
+            const percentage = totalCreditsUsed > 0 ? Math.round(credits / totalCreditsUsed * 100) : 0;
+            const paddedModel = model.padEnd(MODEL_NAME_COLUMN_WIDTH);
+            console.log(`  ${paddedModel}${credits.toLocaleString()} credits (${percentage}%)`);
+          }
+        } else {
+          console.log(`
+No usage data available for the last ${USAGE_DAYS} days.`);
+        }
+        console.log("");
+        break;
+      }
       default:
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");