impact-ui-mcp-server 1.0.2 → 1.0.4

package/TABLECHAT_SCAFFOLD_PLAN.md

@@ -0,0 +1,279 @@
+# TableChat Scaffold Plan – Impact UI MCP Server
+
+This document is the implementation plan for adding a **TableChat scaffold** feature to the impact-ui MCP server. When a team runs a special prompt (e.g. “Add TableChat to my table”), the MCP server returns file contents and instructions so the AI (Cursor in Agent mode) can create or update the right files with minimal code for the consumer.
+
+---
+
+## 1. Goal
+
+- **Consumer flow**: Team has a TableWrapper (or similar) that uses impact-ui `Table`. They want to enable TableChat.
+- **One-time setup**: Scaffold creates `chat.service.js`, table-chat constants, axios/env setup, and `useTableChat.js` (plus optional TableWrapper example).
+- **Per-table**: When adding chat to another table, only **objectType** and **uniqueRowId** (and optionally **channelName**) are needed; constants get a new table config block.
+- **Parameters**:
+  - **First time**: `objectType` (required), `uniqueRowId` (required), `appCode` (optional, default e.g. `"promosmart"`), `channelName` (optional, default e.g. `"promo_name"`).
+  - **Add table**: `objectType` (required), `uniqueRowId` (required), `tableName` (for constant key, e.g. `"WORKBENCH_TABLE"`), optionally `channelName`.
+
+---
+
+## 2. Files to Scaffold (Copy-Paste with Parameterization)
+
+### 2.1 Core three files (user-provided content)
+
+| File | Purpose | Parameterization |
+|------|----------|-------------------|
+| **chat.service.js** | All TableChat API calls using `TABLE_CHAT_API` | Only the **axios import path** may vary by project (e.g. `../axios` vs `@/utils/axios`). |
+| **constants (table chat)** | Table-agnostic config + **per-table** `TABLE_CHAT_CONFIG_FOR_*` | **objectType**, **uniqueRowId**, **appCode**, **channelName**, **tableName** (for constant key). |
+| **useTableChat.js** | Hook that wires chat config, WebSocket, URL filter, column modifier, chat props | **Import paths** (utils, constants, hooks, assets, helpers) – parameterized by a **base path** or path convention. |
+
+### 2.2 Constants file – what varies table-by-table
+
+From your constants, the **table-specific** part is:
+
+```js
+// Basic table chat configuration – one block per table
+const TABLE_CHAT_CONFIG_FOR_<TABLE_NAME> = {
+  objectType: "<objectType>",      // tableCode – required, varies per table
+  channelName: "<channelName>",    // column field for chat icon – optional default
+  uniqueRowId: "<uniqueRowId>",    // row ID field – required, varies per table
+  appCode: APP_CODE,               // project-level – set once
+  maxReconnectAttempts: MAX_RECONNECT_ATTEMPTS,
+};
+```
+
+- **First time**: Create full constants file with one such block; user supplies **objectType**, **uniqueRowId**, and optionally **appCode**, **channelName**.
+- **Add table**: Return only a **new** `TABLE_CHAT_CONFIG_FOR_<TABLE_NAME>` block + short instructions to merge into existing constants and re-export.
+
+### 2.3 Axios and env (not a separate “file” but part of scaffold response)
+
+- **Env**: User must add to `.env` (or `.env.example`):
+  - `REACT_APP_TABLE_CHAT_BASE_URL='https://gap.devs.impactsmartsuite.com/pricesmart-shared/api/v3'`  
+  - (URL will change per project.)
+- **Axios instance**: In the project’s existing axios file (e.g. `utils/axios.js`), add:
+  - `TABLE_CHAT_API` created with `baseURL: process.env.REACT_APP_TABLE_CHAT_BASE_URL` (or `REACT_APP_TABLE_CHAT_API_BASE_URL` to match your naming).
+
+Scaffold output should include an **env snippet** and an **axios snippet** so the AI can add them.
+
+---
+
+## 3. Dependency Graph (useTableChat.js)
+
+`useTableChat.js` depends on:
+
+- **Hooks**: `useChat`, `useUrlChatFilter`, `useTopicWebSocket`, `useTableVisibleRows`
+- **Services**: `chat.service.js` (and axios with `TABLE_CHAT_API`)
+- **Constants**: table-chat constants
+- **Helpers**: `SpecialBadgeWrapperCellRenderer`, `ChatColumnCellRenderer` (e.g. from `tableCellRendererHelpers`)
+- **UI**: `Tooltip` from `impact-ui`, chat icon asset (e.g. `chatMsgIcon.svg`)
+- **Redux**: `useDispatch`, `toastError` (or equivalent)
+- **Modal**: `ChatJourneyModal` (and its storage key from constants)
+
+These are **not** in the impact-ui repo; they live in the consuming project (e.g. PromoSmart). So:
+
+- **Option A (recommended for “copy-paste in any project”)**: You provide **templates** for `useChat`, `useUrlChatFilter`, `useTopicWebSocket`, `useTableVisibleRows`, and optionally the cell renderer helpers + `ChatJourneyModal`, and the MCP server bundles them so the scaffold is self-contained.
+- **Option B**: Scaffold only the **three files** + env + axios + TableWrapper example; document the list above as **prerequisites** (team must add these hooks/helpers from a shared repo or implement them).
+
+The plan below assumes **Option B** for the first version (scaffold the three files + env + axios + integration doc). If you later add the missing hooks/helpers as templates, the same MCP tool can append more entries to the `files` array.
+
+---
+
+## 4. MCP Tool Design
+
+### 4.1 Tool name
+
+- `scaffold_table_chat` (or `get_table_chat_scaffold`).
+
+### 4.2 Input schema
+
+```ts
+{
+  mode: "first_time" | "add_table";
+  objectType: string;   // required – tableCode for this table
+  uniqueRowId: string; // required – row ID field (e.g. "promo_id")
+  tableName?: string;  // for add_table – e.g. "WORKBENCH_TABLE" (used in TABLE_CHAT_CONFIG_FOR_<TABLE_NAME>)
+  appCode?: string;    // optional – default "promosmart" (first_time)
+  channelName?: string; // optional – default "promo_name" (column to show chat icon)
+  paths?: {
+    services?: string;   // e.g. "src/utils/services"
+    constants?: string;  // e.g. "src/constants"
+    hooks?: string;     // e.g. "src/customHooks"
+    axios?: string;     // e.g. "src/utils/axios"
+  };
+}
+```
+
+- **first_time**: Create `chat.service.js`, constants file (with one table config), env snippet, axios snippet, `useTableChat.js`, and optionally a TableWrapper example. Require **objectType** and **uniqueRowId**; **appCode** and **channelName** are optional with defaults.
+- **add_table**: Return only the new `TABLE_CHAT_CONFIG_FOR_<tableName>` block + instructions to merge into existing constants + how to use `chatConfig` in the table usage.
+
+### 4.3 Output shape (so the AI can create/update files)
+
+```ts
+{
+  instructions: string;        // Markdown: what to do (add env, add axios, create files, wire TableWrapper)
+  envSnippet?: string;        // Line(s) for .env
+  axiosSnippet?: string;      // Code to add to axios file (TABLE_CHAT_API)
+  files: Array<{
+    path: string;             // e.g. "src/utils/services/chat.service.js"
+    content: string;          // Full file content (with placeholders replaced)
+    action: "create" | "merge"; // merge = add to existing file (e.g. constants)
+  }>;
+  integrationSnippet?: string; // Minimal TableWrapper + actual table usage (as in your example)
+}
+```
+
+- For **first_time**, `files` includes at least:
+  - `chat.service.js`
+  - table-chat constants file (one table config)
+  - `useTableChat.js`
+- For **add_table**, `files` can be a single item with `action: "merge"` and content = only the new `TABLE_CHAT_CONFIG_FOR_*` block + export line, plus `instructions` explaining where to paste it.
+
+---
+
+## 5. First-Time Setup Flow (Step-by-Step)
+
+1. **User prompt** (e.g. in Cursor):  
+   “Add TableChat feature from impact-ui for my table. objectType: `landing_workbench_table`, uniqueRowId: `promo_id`.”  
+   Optionally: “appCode: promosmart, channelName: promo_name.”
+
+2. **AI** calls MCP tool:  
+   `scaffold_table_chat({ mode: "first_time", objectType: "landing_workbench_table", uniqueRowId: "promo_id", appCode: "promosmart", channelName: "promo_name" })`.
+
+3. **MCP server** returns:
+   - **instructions**: Add `REACT_APP_TABLE_CHAT_BASE_URL` to `.env`, add `TABLE_CHAT_API` to axios file, create the following files, then wire TableWrapper as in the snippet.
+   - **envSnippet**: `REACT_APP_TABLE_CHAT_BASE_URL='https://...'`
+   - **axiosSnippet**: `const TABLE_CHAT_API = axios.create({ baseURL: process.env.REACT_APP_TABLE_CHAT_BASE_URL, ... });` and export.
+   - **files**:
+     - `src/utils/services/chat.service.js` (content from your chat.service.js; import from `../axios` or from `paths.axios`).
+     - `src/constants/tableChatConstants.js` (or similar): full constants file with `TABLE_CHAT_CONFIG_FOR_WORKBENCH_TABLE` (or a generic name) using the given objectType, uniqueRowId, appCode, channelName.
+     - `src/customHooks/useTableChat.js`: content with import paths resolved (e.g. from `paths` or a convention like `@/utils/services/chat.service`, `@/constants/tableChatConstants`).
+   - **integrationSnippet**: Your TableWrapper example + actual table usage with `chatConfig={{ selectedRows, uniqueRowId, objectType }}`.
+
+4. **AI** (Agent mode) creates/edits files in the user’s project and adds the env line and axios snippet.
+
+5. **User** ensures dependencies of `useTableChat` exist (useChat, useUrlChatFilter, useTopicWebSocket, useTableVisibleRows, tableCellRendererHelpers, ChatJourneyModal, etc.) – either from a shared repo or by adding them in a later scaffold phase.
+
+---
+
+## 6. Add-Table Flow
+
+1. **User prompt**:  
+   “Add TableChat for another table: objectType: `landing_marketing_calendar_promos_table`, uniqueRowId: `promo_id`, tableName: MARKETING_CALENDAR_PROMOS_TABLE.”
+
+2. **AI** calls:  
+   `scaffold_table_chat({ mode: "add_table", objectType: "landing_marketing_calendar_promos_table", uniqueRowId: "promo_id", tableName: "MARKETING_CALENDAR_PROMOS_TABLE", channelName: "promo_name" })`.
+
+3. **MCP server** returns:
+   - **instructions**: Merge the following block into your existing table-chat constants file and add the new config to the export. Then use `chatConfig={{ ... TABLE_CHAT_CONFIG_FOR_MARKETING_CALENDAR_PROMOS_TABLE }}` (or pass objectType/uniqueRowId) in your TableWrapper for that table.
+   - **files**: One item with `action: "merge"`, path = existing constants file, content = the new `TABLE_CHAT_CONFIG_FOR_MARKETING_CALENDAR_PROMOS_TABLE` block + export update.
+   - **integrationSnippet**: Example usage for the new table (same pattern as workbench).
+
+4. **AI** merges the block into the constants file and optionally updates the table usage.
+
+---
+
+## 7. Path Conventions and Placeholders
+
+- **Templates** should use placeholders so the MCP server (or the AI) can replace them:
+  - `{{OBJECT_TYPE}}`, `{{UNIQUE_ROW_ID}}`, `{{APP_CODE}}`, `{{CHANNEL_NAME}}`, `{{TABLE_NAME}}`
+  - `{{IMPORT_AXIOS}}` (e.g. `from "../axios"` or `from "@/utils/axios"`)
+  - `{{IMPORT_CONSTANTS}}`, `{{IMPORT_CHAT_SERVICE}}`, `{{IMPORT_USE_CHAT}}`, etc., or a single **base path** (e.g. `@/`) so all imports are consistent.
+- **Default paths** (if `paths` is omitted):
+  - services: `src/utils/services`
+  - constants: `src/constants`
+  - hooks: `src/customHooks`
+  - axios: `src/utils/axios`
+
+---
+
+## 8. TableWrapper and Actual Table Usage (Reference)
+
+- **TableWrapper** (your example): Uses `useTableChat({ chatConfig, tableRef, rowData, showChatIconOnColumn, visibleRowsIds, isEnabled })`, then `getChatProps()`, `getChatColumnModifier(columnDefs)`, and spreads `...chatProps` and applies `getChatColumnModifier(defaultColumnDefs)` to column defs. Chat journey modal uses `chatConfig.journeyModalStorageKey` and `chatConfig.journeyModalConfig`.
+- **Actual table** (your example):  
+  `<TableWrapper ... chatConfig={{ selectedRows: workbenchSelectedOffers, uniqueRowId: "promo_id", objectType: TABLE_VIEW_TABLE_NAME.LANDING_WORKBENCH_TABLE }} ... />`  
+  So after scaffold, the consumer only needs to pass **objectType** (e.g. from a table name constant) and **uniqueRowId** (and optionally **channelName**); the rest comes from the scaffolded constants and hook.
+
+The **integrationSnippet** in the scaffold response should mirror this so the AI can paste or adapt it into the project.
+
+---
+
+## 9. Recommended User Prompts (for documentation)
+
+Document these so teams know what to ask:
+
+- **First-time setup**:  
+  “Add TableChat feature from impact-ui. objectType: \<tableCode\>, uniqueRowId: \<rowIdField\>. [Optional: appCode: promosmart, channelName: promo_name]”
+- **Add another table**:  
+  “Add TableChat for another table: objectType: \<tableCode\>, uniqueRowId: \<rowIdField\>, tableName: \<CONSTANT_NAME\>.”
+
+The AI should then call `scaffold_table_chat` with the appropriate `mode` and parameters.
+
+### Example prompts (copy-paste for teams)
+
+**First time (e.g. Workbench table):**
+```
+Add TableChat feature from impact-ui for my table.
+objectType: landing_workbench_table
+uniqueRowId: promo_id
+[Optional: appCode: promosmart, channelName: promo_name]
+```
+
+**Add another table (e.g. Marketing Calendar Promos):**
+```
+Add TableChat for another table from impact-ui.
+objectType: landing_marketing_calendar_promos_table
+uniqueRowId: promo_id
+tableName: MARKETING_CALENDAR_PROMOS_TABLE
+channelName: promo_name
+```
+
+---
+
+## 10. Implementation Checklist (MCP Server)
+
+- [ ] Add **templates** directory under `mcp-server/` (e.g. `templates/table-chat/`) with:
+  - `chat.service.js.template`
+  - `tableChatConstants.js.template`
+  - `useTableChat.js.template`
+  - (Optional) `axios-snippet.txt`, `env-snippet.txt`
+- [ ] Implement **scaffold_table_chat** tool in `src/index.js`:
+  - Read templates (from package path via `import.meta.url` / `__dirname`).
+  - Replace placeholders with tool args (objectType, uniqueRowId, appCode, channelName, tableName, paths).
+  - Return `{ instructions, envSnippet, axiosSnippet, files, integrationSnippet }`.
+- [ ] For **add_table**, either:
+  - Return only the new constant block + instructions to merge, or
+  - Accept `constantsFilePath` and return a full “merged” constants file (more complex; optional).
+- [ ] Document **prerequisites** (useChat, useUrlChatFilter, useTopicWebSocket, useTableVisibleRows, tableCellRendererHelpers, ChatJourneyModal) in MCP server docs or in the `instructions` text so teams know what they must add if not scaffolded.
+- [ ] Add **TABLE_CHAT_API** and **REACT_APP_TABLE_CHAT_BASE_URL** to any existing ENV doc (e.g. `ENV_VARIABLES.md`).
+- [ ] Add `templates` and `TABLECHAT_SCAFFOLD_PLAN.md` to the `files` array in `package.json` so they are published with the npm package.
+
+---
+
+## 11. Summary
+
+| Item | Detail |
+|------|--------|
+| **Core files** | chat.service.js, table-chat constants, useTableChat.js |
+| **Constants vary by table** | objectType, uniqueRowId (required); appCode, channelName (optional with defaults) |
+| **First time** | Require objectType + uniqueRowId; optional appCode, channelName; create services, constants, hook, env, axios snippet, TableWrapper snippet |
+| **Add table** | Require objectType + uniqueRowId (+ tableName for constant key); return new TABLE_CHAT_CONFIG block + merge instructions |
+| **Env** | REACT_APP_TABLE_CHAT_BASE_URL (or REACT_APP_TABLE_CHAT_API_BASE_URL) |
+| **Dependencies of useTableChat** | useChat, useUrlChatFilter, useTopicWebSocket, useTableVisibleRows, tableCellRendererHelpers, ChatJourneyModal, Redux toast, asset – document or bundle as templates later |
+
+This plan allows any project with a TableWrapper-style setup to implement TableChat with a single prompt and minimal manual code (objectType, uniqueRowId, and optionally appCode/channelName/tableName), while keeping the “three files” (service, constants, useTableChat) as the main scaffold payload and constants as the only table-varying part.
+
+---
+
+## 12. Next steps for implementation
+
+1. **Add template files** in `mcp-server/templates/table-chat/`:
+   - Paste your `chat.service.js` → save as `chat.service.js.template`, replace axios import with `{{IMPORT_AXIOS}}`.
+   - Paste your table-chat constants → save as `tableChatConstants.js.template`, replace first table config with `{{OBJECT_TYPE}}`, `{{UNIQUE_ROW_ID}}`, `{{APP_CODE}}`, `{{CHANNEL_NAME}}`, `{{TABLE_NAME}}`.
+   - Paste your `useTableChat.js` → save as `useTableChat.js.template`, replace all import paths with the placeholders listed in `templates/table-chat/README.md`.
+   - Add `axios-snippet.txt` and `env-snippet.txt` (and optionally `integration-snippet.jsx.template`).
+
+2. **Implement the tool** in `mcp-server/src/`:
+   - Create `tools/tableChatScaffold.js` (or similar): read templates from `templates/table-chat/`, replace placeholders with tool args, build `files` array and return payload.
+   - In `index.js`: register `scaffold_table_chat` in `ListToolsRequestSchema` and handle `CallToolRequestSchema` for it.
+
+3. **Resolve template path**: Use `import.meta.url` / `path.dirname(fileURLToPath(import.meta.url))` in the tool to resolve the path to `templates/table-chat/` relative to the MCP server package so it works when installed from npm.
+
+4. **Document** in MCP server README or USAGE: how to run the special prompt and that useChat, useUrlChatFilter, useTopicWebSocket, useTableVisibleRows, and table helpers are required (or add those templates in a later phase).

package/generate-cursor-config.js

@@ -102,21 +102,51 @@ if (useNpm) {
     console.log("   Make sure to install: npm install impact-ui-mcp-server\n");
   }
 } else {
-  // Local development configuration
-  const mcpServerPath = resolve(__dirname);
-  const indexPath = resolve(__dirname, "src/index.js");
+  // For npm packages (when run from a project), use ${workspaceFolder} variables
+  // Try to detect if we're in a project with node_modules
+  const cwd = process.cwd();
+  let mcpServerPath = "${workspaceFolder}/frontend/node_modules/impact-ui-mcp-server/src/index.js";
+  let impactUiPath = "${workspaceFolder}/frontend/node_modules/impact-ui";
+  
+  // Check actual structure to determine which path to use
+  const frontendMcpPath = resolve(cwd, "frontend", "node_modules", "impact-ui-mcp-server", "src", "index.js");
+  const rootMcpPath = resolve(cwd, "node_modules", "impact-ui-mcp-server", "src", "index.js");
+  
+  if (existsSync(frontendMcpPath)) {
+    // Packages are in frontend/node_modules
+    mcpServerPath = "${workspaceFolder}/frontend/node_modules/impact-ui-mcp-server/src/index.js";
+    impactUiPath = "${workspaceFolder}/frontend/node_modules/impact-ui";
+  } else if (existsSync(rootMcpPath)) {
+    // Packages are in root node_modules
+    mcpServerPath = "${workspaceFolder}/node_modules/impact-ui-mcp-server/src/index.js";
+    impactUiPath = "${workspaceFolder}/node_modules/impact-ui";
+  }
+  
+  // Check for scoped package name
+  const frontendScopedMcpPath = resolve(cwd, "frontend", "node_modules", "@impact-analytics", "impact-ui-mcp-server", "src", "index.js");
+  const rootScopedMcpPath = resolve(cwd, "node_modules", "@impact-analytics", "impact-ui-mcp-server", "src", "index.js");
+  
+  if (existsSync(frontendScopedMcpPath)) {
+    mcpServerPath = "${workspaceFolder}/frontend/node_modules/@impact-analytics/impact-ui-mcp-server/src/index.js";
+  } else if (existsSync(rootScopedMcpPath)) {
+    mcpServerPath = "${workspaceFolder}/node_modules/@impact-analytics/impact-ui-mcp-server/src/index.js";
+  }
 
   config = {
     "mcp.servers": {
       "impact-ui": {
         "command": "node",
-        "args": [indexPath],
-        "cwd": mcpServerPath
+        "args": [mcpServerPath],
+        "cwd": "${workspaceFolder}",
+        "env": {
+          "IMPACT_UI_NODE_MODULES": impactUiPath
+        }
       }
     }
   };
 
-  console.log("\n🏠 Local Development Configuration\n");
+  console.log("\n📦 NPM Package Configuration (with ${workspaceFolder} variables)\n");
+  console.log("💡 Detected package structure and using ${workspaceFolder} variables for Cursor.\n");
 }
 
 console.log("Add this to your Cursor settings.json:\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impact-ui-mcp-server",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "MCP Server for Impact UI Library - Provides AI access to component documentation and code examples",
   "type": "module",
   "main": "src/index.js",
@@ -11,6 +11,8 @@
     "impact-ui-generate-windsurf-config-absolute": "./generate-windsurf-config-absolute.js"
   },
   "files": [
+    "TABLECHAT_SCAFFOLD_PLAN.md",
+    "templates",
     "src",
     "generate-cursor-config.js",
     "generate-windsurf-config.js",
@@ -56,4 +58,4 @@
     "glob": "^10.3.10",
     "fs-extra": "^11.1.1"
   }
-}
+}

package/src/index.js

@@ -15,6 +15,7 @@ import { parseComponentFile } from "./parsers/componentParser.js";
 import { getProjectRoot } from "./utils/fileReader.js";
 import { getComponentInfo } from "./tools/componentInfo.js";
 import { generateCodeExample } from "./tools/codeExample.js";
+import { getTableChatScaffold } from "./tools/tableChatScaffold.js";
 
 // Component registry - populated on startup
 let componentRegistry = {};
@@ -194,6 +195,60 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["componentName"],
         },
       },
+      {
+        name: "scaffold_table_chat",
+        description: "Get scaffold (file contents and instructions) to add TableChat feature to a project using impact-ui Table. Returns useTopicWebSocket hook, chatCellRenderers, env/axios snippets, and integration steps. Use when the user asks to add TableChat or implement table chat.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            mode: {
+              type: "string",
+              description: "first_time (default) or add_table",
+              enum: ["first_time", "add_table"],
+            },
+            objectType: {
+              type: "string",
+              description: "Table code / object type (e.g. promo, landing_workbench_table). Required.",
+            },
+            uniqueRowId: {
+              type: "string",
+              description: "Row ID field name (e.g. promo_id). Required.",
+            },
+            tableName: {
+              type: "string",
+              description: "Constant key suffix for add_table (e.g. WORKBENCH_TABLE).",
+            },
+            appCode: {
+              type: "string",
+              description: "Project app code (default: promosmart).",
+            },
+            channelName: {
+              type: "string",
+              description: "Column field to show chat icon on (default: promo_name).",
+            },
+            paths: {
+              type: "object",
+              description: "Optional paths: hooks, services, helpers, axios, constants.",
+              properties: {
+                hooks: { type: "string" },
+                services: { type: "string" },
+                helpers: { type: "string" },
+                axios: { type: "string" },
+                constants: { type: "string" },
+              },
+            },
+            reactRouterPackage: {
+              type: "string",
+              description: "Package for useSearchParams in useUrlChatFilter (default: react-router-dom-v5-compat). Use react-router-dom for v6.",
+            },
+            lodashPackage: {
+              type: "string",
+              description: "Package for debounce in useTableVisibleRows (default: lodash). Use lodash-es if needed.",
+            },
+          },
+          required: ["objectType", "uniqueRowId"],
+        },
+      },
     ],
   };
 });
@@ -528,6 +583,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      case "scaffold_table_chat": {
+        const scaffoldMarkdown = getTableChatScaffold({
+          mode: args.mode || "first_time",
+          objectType: args.objectType,
+          uniqueRowId: args.uniqueRowId,
+          tableName: args.tableName,
+          appCode: args.appCode,
+          channelName: args.channelName,
+          paths: args.paths,
+          reactRouterPackage: args.reactRouterPackage,
+          lodashPackage: args.lodashPackage,
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: scaffoldMarkdown,
+            },
+          ],
+        };
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }