sandal-db 1.0.0 → 1.0.2

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
+import fs4 from "node:fs";
 import { Command } from "commander";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import ora2 from "ora";
 import { input as input2, select, confirm as confirm2 } from "@inquirer/prompts";
 
@@ -183,6 +184,69 @@ function resolveCredentials(options) {
     }
   };
 }
+function removeApiKey(provider) {
+  const filePath = getConfigFilePath();
+  const dirPath = getConfigDirPath();
+  const cfg = readConfig();
+  if (provider === "all") {
+    delete cfg.geminiApiKey;
+    delete cfg.openaiApiKey;
+    delete cfg.anthropicApiKey;
+  } else if (provider === "google") {
+    delete cfg.geminiApiKey;
+  } else if (provider === "openai") {
+    delete cfg.openaiApiKey;
+  } else if (provider === "anthropic") {
+    delete cfg.anthropicApiKey;
+  }
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true, mode: 448 });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(cfg, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function getSavedConnections() {
+  const cfg = readConfig();
+  const list = Array.isArray(cfg.savedConnections) ? [...cfg.savedConnections] : [];
+  if (cfg.dbUrl && !list.includes(cfg.dbUrl)) {
+    list.unshift(cfg.dbUrl);
+  }
+  return list;
+}
+function addSavedConnection(rawUrl) {
+  if (!rawUrl || typeof rawUrl !== "string") return;
+  const trimmed = rawUrl.trim();
+  if (!trimmed) return;
+  const current = getSavedConnections();
+  const filtered = current.filter((u) => u !== trimmed);
+  const updated = [trimmed, ...filtered].slice(0, 20);
+  writeConfig({
+    savedConnections: updated
+  });
+}
+function removeSavedConnection(target) {
+  const current = getSavedConnections();
+  let updated;
+  if (typeof target === "number") {
+    const idx = target - 1;
+    if (idx < 0 || idx >= current.length) return false;
+    updated = current.filter((_, i) => i !== idx);
+  } else {
+    const normalized = target.trim();
+    if (!current.includes(normalized)) return false;
+    updated = current.filter((u) => u !== normalized);
+  }
+  writeConfig({
+    savedConnections: updated
+  });
+  return true;
+}
 
 // src/db/postgres.ts
 import pg from "pg";
@@ -902,7 +966,8 @@ function createChatModel(options) {
 
 // src/repl.ts
 import readline from "node:readline";
-import chalk2 from "chalk";
+import fs3 from "node:fs";
+import chalk3 from "chalk";
 import boxen2 from "boxen";
 import ora from "ora";
 import Table from "cli-table3";
@@ -1603,7 +1668,7 @@ var OBVIOUS_DATABASE_PATTERNS = [
   /\b(?:how many (?:users|rows|records|orders|items|products|documents))\b/i,
   /\b(?:database|postgres|mongodb|mongo|pg_)\b/i
 ];
-async function classifyIntent(input3, model) {
+async function classifyIntent(input3, model, historyContext) {
   const trimmed = input3.trim();
   for (const pattern of OBVIOUS_OUT_OF_SCOPE_PATTERNS) {
     if (pattern.test(trimmed)) {
@@ -1623,12 +1688,23 @@ async function classifyIntent(input3, model) {
   if (/^(?:tables|collections|schema|indexes|views|stats|count|info)$/i.test(trimmed)) {
     return { isDatabaseTask: true };
   }
+  if (historyContext && /^(?:now\s+|and\s+|also\s+|then\s+)?(?:count|sort|filter|show|order|group|limit|delete|update|find|export|why|how many|what about|which ones?|where)\b/i.test(trimmed)) {
+    return { isDatabaseTask: true };
+  }
   if (!model) {
     return { isDatabaseTask: true };
   }
   try {
+    const promptText = historyContext ? `${INTENT_CLASSIFICATION_PROMPT}
+
+Recent conversation context:
+${historyContext}
+
+Current user request:
+${trimmed}` : `${INTENT_CLASSIFICATION_PROMPT}
+${trimmed}`;
     const response = await model.invoke([
-      new HumanMessage(INTENT_CLASSIFICATION_PROMPT + "\n" + trimmed)
+      new HumanMessage(promptText)
     ]);
     const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
     const jsonMatch = content.match(/\{[\s\S]*?\}/);
@@ -1738,6 +1814,7 @@ function createDatabaseAgent(config) {
     };
   }
   async function identifyTargetsNode(state) {
+    const historyMessages = state.messages.slice(-4);
     const prompt = `Based on this user request: "${state.userInput}"
 And the available database schema:
 ${state.schemaSummary}
@@ -1745,7 +1822,10 @@ ${state.schemaSummary}
 List the relevant table names (PostgreSQL) or collection names (MongoDB) needed to fulfill the request.
 Respond with a JSON array of string names only, e.g. ["users", "orders"]. Do not include markdown codeblocks or extra text.`;
     try {
-      const response = await model.invoke([new HumanMessage2(prompt)]);
+      const response = await model.invoke([
+        ...historyMessages,
+        new HumanMessage2(prompt)
+      ]);
       const content = typeof response.content === "string" ? response.content.trim() : "";
       const match = content.match(/\[[\s\S]*?\]/);
       const targets = match ? JSON.parse(match[0]) : [];
@@ -1938,15 +2018,21 @@ Ground your response strictly in the query results above. Never hallucinate rows
     try {
       const response = await model.invoke([new HumanMessage2(prompt)]);
       const conclusion = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      const queryStr = state.generatedQuery?.sql || state.generatedQuery?.rawDisplay;
+      const historyAiText = queryStr ? `[Executed Query: ${queryStr}]
+${conclusion}` : conclusion;
       return {
         conclusion,
-        messages: [new HumanMessage2(state.userInput), new AIMessage(conclusion)]
+        messages: [new HumanMessage2(state.userInput), new AIMessage(historyAiText)]
       };
     } catch (err) {
       const conclusion = `Query executed successfully (${res.rowCount ?? 0} rows, ${res.durationMs}ms).`;
+      const queryStr = state.generatedQuery?.sql || state.generatedQuery?.rawDisplay;
+      const historyAiText = queryStr ? `[Executed Query: ${queryStr}]
+${conclusion}` : conclusion;
       return {
         conclusion,
-        messages: [new HumanMessage2(state.userInput), new AIMessage(conclusion)]
+        messages: [new HumanMessage2(state.userInput), new AIMessage(historyAiText)]
       };
     }
   }
@@ -1961,27 +2047,282 @@ Ground your response strictly in the query results above. Never hallucinate rows
   return app;
 }
 
+// src/markdown.ts
+import { Marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import chalk2 from "chalk";
+function createMarkdownRenderer(options = {}) {
+  const terminalOptions = {
+    heading: chalk2.bold.cyan,
+    firstHeading: chalk2.bold.cyan.underline,
+    codespan: chalk2.yellow,
+    code: chalk2.yellow,
+    blockquote: chalk2.gray.italic,
+    hr: (input3) => {
+      const w = Math.min(options.width ?? (process.stdout.columns || 80), 80);
+      return chalk2.gray(input3 && input3.trim() ? input3 : "\u2500".repeat(w));
+    },
+    table: chalk2.reset,
+    tableOptions: {
+      style: {
+        head: ["cyan", "bold"],
+        border: ["gray"]
+      }
+    },
+    tab: 2,
+    showSectionPrefix: true,
+    reflowText: false,
+    width: options.width ?? (process.stdout.columns || 80),
+    ...options
+  };
+  const marked = new Marked();
+  marked.use(markedTerminal(terminalOptions, options.highlightOptions));
+  return marked;
+}
+var defaultRenderer = null;
+function getDefaultRenderer() {
+  if (!defaultRenderer) {
+    defaultRenderer = createMarkdownRenderer();
+  }
+  return defaultRenderer;
+}
+function renderMarkdown(content, options) {
+  if (!content || typeof content !== "string") {
+    return "";
+  }
+  try {
+    const renderer = options ? createMarkdownRenderer(options) : getDefaultRenderer();
+    const result = renderer.parse(content);
+    const parsedStr = typeof result === "string" ? result : String(result);
+    return parsedStr.replace(/\n+$/, "");
+  } catch {
+    return content;
+  }
+}
+
+// src/agent/memory.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { HumanMessage as HumanMessage3, AIMessage as AIMessage2 } from "@langchain/core/messages";
+function getChatsDirPath() {
+  return path2.join(getConfigDirPath(), "chats");
+}
+var ChatMemoryManager = class {
+  chatsDir;
+  constructor(customDir) {
+    this.chatsDir = customDir || getChatsDirPath();
+    this.ensureDirectory();
+  }
+  ensureDirectory() {
+    if (!fs2.existsSync(this.chatsDir)) {
+      try {
+        fs2.mkdirSync(this.chatsDir, { recursive: true, mode: 448 });
+      } catch {
+      }
+    }
+  }
+  getFilePath(sessionId) {
+    const safeId = sessionId.replace(/[^a-zA-Z0-9_\-]/g, "_");
+    return path2.join(this.chatsDir, `${safeId}.json`);
+  }
+  /**
+   * Create a new chat session.
+   */
+  createSession(initialTitle, dbUrl) {
+    const id = `chat-${Date.now()}`;
+    const session = {
+      id,
+      title: initialTitle || "New Chat",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      dbUrl,
+      messages: []
+    };
+    this.saveSession(session);
+    return session;
+  }
+  /**
+   * Load an existing session by ID.
+   */
+  getSession(sessionId) {
+    const file = this.getFilePath(sessionId);
+    try {
+      if (fs2.existsSync(file)) {
+        const content = fs2.readFileSync(file, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+      return void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Save or update a session to disk.
+   */
+  saveSession(session) {
+    this.ensureDirectory();
+    session.updatedAt = Date.now();
+    const file = this.getFilePath(session.id);
+    try {
+      fs2.writeFileSync(file, JSON.stringify(session, null, 2), {
+        encoding: "utf-8",
+        mode: 384
+      });
+    } catch {
+    }
+  }
+  /**
+   * List all stored sessions sorted by last updated time (newest first).
+   */
+  listSessions() {
+    this.ensureDirectory();
+    try {
+      const files = fs2.readdirSync(this.chatsDir).filter((f) => f.endsWith(".json"));
+      const summaries = [];
+      for (const f of files) {
+        try {
+          const filePath = path2.join(this.chatsDir, f);
+          const raw = fs2.readFileSync(filePath, "utf-8");
+          const session = JSON.parse(raw);
+          if (session && session.id) {
+            summaries.push({
+              id: session.id,
+              title: session.title || "Untitled Chat",
+              messageCount: session.messages ? session.messages.length : 0,
+              createdAt: session.createdAt || 0,
+              updatedAt: session.updatedAt || 0,
+              dbUrl: session.dbUrl ? maskUrl(session.dbUrl) : void 0
+            });
+          }
+        } catch {
+        }
+      }
+      return summaries.sort((a, b) => b.updatedAt - a.updatedAt);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Append a message to a session, updating session title if first turn.
+   */
+  addMessage(sessionId, message, dbUrl) {
+    let session = this.getSession(sessionId);
+    if (!session) {
+      session = {
+        id: sessionId,
+        title: message.content.slice(0, 40).trim() || "New Chat",
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        dbUrl,
+        messages: []
+      };
+    }
+    if (dbUrl && !session.dbUrl) {
+      session.dbUrl = dbUrl;
+    }
+    if (message.role === "user" && (session.title === "New Chat" || !session.title)) {
+      session.title = message.content.slice(0, 45).trim();
+    }
+    session.messages.push({
+      ...message,
+      timestamp: Date.now()
+    });
+    this.saveSession(session);
+    return session;
+  }
+  /**
+   * Convert stored history into LangChain messages for model prompts.
+   */
+  toLangChainMessages(sessionId, maxTurns = 6) {
+    const session = this.getSession(sessionId);
+    if (!session || !session.messages || session.messages.length === 0) {
+      return [];
+    }
+    const recent = session.messages.slice(-maxTurns);
+    const result = [];
+    for (const m of recent) {
+      if (m.role === "user") {
+        result.push(new HumanMessage3(m.content));
+      } else if (m.role === "assistant") {
+        let text = m.content;
+        if (m.query) {
+          text = `[Executed Query: ${m.query}]
+${text}`;
+        }
+        result.push(new AIMessage2(text));
+      }
+    }
+    return result;
+  }
+  /**
+   * Get a compact text representation of recent turns for guardrail/target classification.
+   */
+  getRecentSummary(sessionId, maxTurns = 4) {
+    const session = this.getSession(sessionId);
+    if (!session || !session.messages || session.messages.length === 0) {
+      return "";
+    }
+    const recent = session.messages.slice(-maxTurns);
+    return recent.map((m) => {
+      const prefix = m.role === "user" ? "User:" : "Assistant:";
+      const q = m.query ? ` (Query: ${m.query})` : "";
+      return `${prefix} ${m.content}${q}`;
+    }).join("\n");
+  }
+  /**
+   * Clear all messages from a session.
+   */
+  clearSession(sessionId) {
+    const session = this.getSession(sessionId);
+    if (session) {
+      session.messages = [];
+      this.saveSession(session);
+    }
+  }
+  /**
+   * Delete a session file permanently.
+   */
+  deleteSession(sessionId) {
+    const file = this.getFilePath(sessionId);
+    try {
+      if (fs2.existsSync(file)) {
+        fs2.unlinkSync(file);
+        return true;
+      }
+    } catch {
+      return false;
+    }
+    return false;
+  }
+};
+
 // src/repl.ts
 var ReplSession = class {
   adapter;
   model;
   provider;
   modelName;
+  apiKey;
   strictMode;
   allowFullWipe;
   rowThreshold;
+  renderMarkdown;
   isRunning = true;
-  sessionId = `session-${Date.now()}`;
+  sessionId;
   agent;
+  memoryManager;
+  classifierOptions;
   constructor(options) {
     this.adapter = options.adapter;
     this.model = options.model;
     this.provider = options.provider;
     this.modelName = options.modelName;
+    this.apiKey = options.apiKey;
     this.strictMode = options.strictMode;
     this.allowFullWipe = options.allowFullWipe;
     this.rowThreshold = options.rowThreshold ?? 50;
-    const classifierOptions = {
+    this.renderMarkdown = options.renderMarkdown ?? true;
+    this.classifierOptions = {
       strictMode: this.strictMode,
       allowFullWipe: this.allowFullWipe,
       rowThresholdForDangerousUpdate: this.rowThreshold
@@ -1989,8 +2330,17 @@ var ReplSession = class {
     this.agent = createDatabaseAgent({
       adapter: this.adapter,
       model: this.model,
-      classifierOptions
+      classifierOptions: this.classifierOptions
     });
+    this.memoryManager = new ChatMemoryManager();
+    const initialSession = this.memoryManager.createSession("New Chat", this.adapter.connectionUrl);
+    this.sessionId = initialSession.id;
+    if (this.adapter.connectionUrl) {
+      addSavedConnection(this.adapter.connectionUrl);
+    }
+  }
+  getPromptText() {
+    return chalk3.cyan(`sandal [${this.adapter.type}]> `);
   }
   async start() {
     this.setupSignalHandlers();
@@ -2000,12 +2350,11 @@ var ReplSession = class {
       output: process.stdout,
       terminal: true
     });
-    const promptText = chalk2.cyan(`sandal [${this.adapter.type}]> `);
     const askQuestion = (query) => {
       return new Promise((resolve) => rl.question(query, resolve));
     };
     while (this.isRunning) {
-      const input3 = await askQuestion(promptText);
+      const input3 = await askQuestion(this.getPromptText());
       const trimmed = input3.trim();
       if (!trimmed) continue;
       if (["exit", "quit", ".exit", ".quit"].includes(trimmed.toLowerCase())) {
@@ -2029,26 +2378,77 @@ var ReplSession = class {
         continue;
       }
       if (trimmed === ".refresh") {
-        const spinner = ora(chalk2.blue("Refreshing schema cache...")).start();
+        const spinner = ora(chalk3.blue("Refreshing schema cache...")).start();
         try {
           await this.adapter.inspectSchema(true);
-          spinner.succeed(chalk2.green("Schema refreshed successfully."));
+          spinner.succeed(chalk3.green("Schema refreshed successfully."));
         } catch (err) {
-          spinner.fail(chalk2.red(`Failed to refresh schema: ${err.message}`));
+          spinner.fail(chalk3.red(`Failed to refresh schema: ${err.message}`));
+        }
+        continue;
+      }
+      if (trimmed.startsWith(".md") || trimmed.startsWith(".markdown")) {
+        const entityOrText = trimmed.replace(/^\.(?:markdown|md)\s*/, "").trim();
+        this.handleRenderMarkdown(entityOrText);
+        continue;
+      }
+      if (trimmed.startsWith(".connect") || trimmed.startsWith(".switch") || trimmed === ".connections" || trimmed === ".databases") {
+        const targetUrl = trimmed.replace(/^\.(?:connect|switch)\s*/, "").trim();
+        await this.handleSwitchConnection(targetUrl, askQuestion);
+        continue;
+      }
+      if (trimmed.startsWith(".model")) {
+        const targetModel = trimmed.replace(/^\.model\s*/, "").trim();
+        await this.handleModelCommand(targetModel, askQuestion);
+        continue;
+      }
+      if (trimmed.startsWith(".provider")) {
+        const targetProvider = trimmed.replace(/^\.provider\s*/, "").trim();
+        await this.handleProviderCommand(targetProvider, askQuestion);
+        continue;
+      }
+      if (trimmed.startsWith(".key")) {
+        const keyArg = trimmed.replace(/^\.key\s*/, "").trim();
+        await this.handleKeyCommand(keyArg, askQuestion);
+        continue;
+      }
+      if (trimmed === ".chats") {
+        this.handleListChats();
+        continue;
+      }
+      if (trimmed === ".new") {
+        this.handleNewChat();
+        continue;
+      }
+      if (trimmed.startsWith(".chat")) {
+        const chatArg = trimmed.replace(/^\.chat\s*/, "").trim();
+        if (!chatArg || chatArg === "new") {
+          this.handleNewChat();
+        } else {
+          this.handleSwitchChat(chatArg);
         }
         continue;
       }
-      const intentSpinner = ora(chalk2.blue("Analyzing intent...")).start();
-      const intent = await classifyIntent(trimmed, this.model);
+      if (trimmed === ".history") {
+        this.handleShowHistory();
+        continue;
+      }
+      if (trimmed === ".clear-chat" || trimmed === ".clear-history") {
+        this.handleClearChat();
+        continue;
+      }
+      const intentSpinner = ora(chalk3.blue("Analyzing intent...")).start();
+      const historySummary = this.memoryManager.getRecentSummary(this.sessionId, 4);
+      const intent = await classifyIntent(trimmed, this.model, historySummary);
       intentSpinner.stop();
       if (!intent.isDatabaseTask) {
         console.log(
           boxen2(
-            `${chalk2.bold.red("\u{1F6E1}\uFE0F GUARDRAIL ENFORCEMENT")}
+            `${chalk3.bold.red("\u{1F6E1}\uFE0F GUARDRAIL ENFORCEMENT")}
 
-${chalk2.yellow(REFUSAL_MESSAGE)}
+${chalk3.yellow(REFUSAL_MESSAGE)}
 
-${chalk2.gray(
+${chalk3.gray(
               `Reason: ${intent.reason || "Non-database request rejected"}`
             )}`,
             {
@@ -2061,11 +2461,13 @@ ${chalk2.gray(
         );
         continue;
       }
-      const agentSpinner = ora(chalk2.cyan("Agent planning query...")).start();
+      const agentSpinner = ora(chalk3.cyan("Agent planning query...")).start();
       try {
+        const historyMessages = this.memoryManager.toLangChainMessages(this.sessionId, 6);
         const result = await this.agent.invoke(
           {
-            userInput: trimmed
+            userInput: trimmed,
+            messages: historyMessages
           },
           {
             configurable: {
@@ -2078,34 +2480,441 @@ ${chalk2.gray(
           this.renderRowsTable(result.queryResult);
         }
         if (result.conclusion) {
-          console.log("\n" + chalk2.green("\u{1F916} Answer:"));
-          console.log(chalk2.white(result.conclusion) + "\n");
+          console.log("\n" + chalk3.green("\u{1F916} Answer:"));
+          if (this.renderMarkdown) {
+            console.log(renderMarkdown(result.conclusion) + "\n");
+          } else {
+            console.log(chalk3.white(result.conclusion) + "\n");
+          }
+        }
+        this.memoryManager.addMessage(
+          this.sessionId,
+          { role: "user", content: trimmed },
+          this.adapter.connectionUrl
+        );
+        if (result.conclusion) {
+          const queryStr = result.generatedQuery?.sql || result.generatedQuery?.rawDisplay;
+          this.memoryManager.addMessage(
+            this.sessionId,
+            {
+              role: "assistant",
+              content: result.conclusion,
+              query: queryStr,
+              rowCount: result.queryResult?.rowCount
+            },
+            this.adapter.connectionUrl
+          );
         }
       } catch (err) {
-        agentSpinner.fail(chalk2.red(`Execution failed: ${err.message}`));
+        agentSpinner.fail(chalk3.red(`Execution failed: ${err.message}`));
       }
     }
     rl.close();
     await this.shutdown();
   }
+  async handleSwitchConnection(targetUrl, ask) {
+    let urlToConnect = targetUrl;
+    if (!urlToConnect) {
+      const saved = getSavedConnections();
+      console.log(chalk3.bold.cyan("\nDatabase Connections:"));
+      if (saved.length === 0) {
+        console.log(chalk3.gray("  (No previous connections saved)"));
+      } else {
+        saved.forEach((url, i) => {
+          const isCurrent = url === this.adapter.connectionUrl;
+          const currentTag = isCurrent ? chalk3.green(" (Current)") : "";
+          console.log(`  [${i + 1}] ${maskUrl(url)}${currentTag}`);
+        });
+      }
+      console.log(chalk3.gray("  [N] Enter a new connection URL"));
+      console.log(chalk3.gray("  [C] Cancel\n"));
+      const choice = (await ask(chalk3.cyan("Select a connection [number, N, C]: "))).trim();
+      if (!choice || choice.toLowerCase() === "c") {
+        return;
+      }
+      if (choice.toLowerCase() === "n") {
+        const entered = (await ask(chalk3.cyan("Enter database connection URL: "))).trim();
+        if (!entered) return;
+        urlToConnect = entered;
+      } else {
+        const num = parseInt(choice, 10);
+        if (!isNaN(num) && num >= 1 && num <= saved.length) {
+          urlToConnect = saved[num - 1];
+        } else {
+          console.log(chalk3.red("Invalid selection."));
+          return;
+        }
+      }
+    }
+    if (urlToConnect === this.adapter.connectionUrl && this.adapter.isConnected()) {
+      console.log(chalk3.yellow("\nAlready connected to this database.\n"));
+      return;
+    }
+    try {
+      detectDatabaseType(urlToConnect);
+    } catch (e) {
+      console.log(chalk3.red(`Invalid connection URL: ${e.message}`));
+      return;
+    }
+    const spinner = ora(`Connecting to ${maskUrl(urlToConnect)}...`).start();
+    try {
+      const newAdapter = createDatabaseAdapter(urlToConnect);
+      await newAdapter.connect();
+      await newAdapter.inspectSchema(true);
+      try {
+        await this.adapter.disconnect();
+      } catch {
+      }
+      this.adapter = newAdapter;
+      this.agent = createDatabaseAgent({
+        adapter: this.adapter,
+        model: this.model,
+        classifierOptions: this.classifierOptions
+      });
+      addSavedConnection(urlToConnect);
+      spinner.succeed(
+        chalk3.green(
+          `Switched to ${newAdapter.type.toUpperCase()} database: ${newAdapter.databaseName} (${newAdapter.getMaskedUrl()})`
+        )
+      );
+      console.log(
+        chalk3.gray(
+          `Chat session [${this.sessionId}] continuing with conversation memory on the new database.
+`
+        )
+      );
+    } catch (err) {
+      spinner.fail(chalk3.red(`Failed to connect to database: ${err.message}`));
+    }
+  }
+  async handleModelCommand(newModel, ask) {
+    let targetModel = newModel;
+    if (!targetModel) {
+      console.log(
+        chalk3.bold.cyan(`
+Current Model: `) + chalk3.white(this.modelName) + chalk3.gray(` (${this.provider})`)
+      );
+      console.log(chalk3.bold.yellow("Suggested models for " + this.provider + ":"));
+      const commonModels = {
+        google: ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.0-flash"],
+        openai: ["gpt-4o", "gpt-4o-mini", "o3-mini"],
+        anthropic: [
+          "claude-3-5-sonnet-latest",
+          "claude-3-5-haiku-latest",
+          "claude-3-7-sonnet-latest"
+        ]
+      };
+      const list = commonModels[this.provider] || [];
+      list.forEach((m, i) => {
+        const isCurrent = m === this.modelName ? chalk3.green(" (Current)") : "";
+        console.log(`  [${i + 1}] ${m}${isCurrent}`);
+      });
+      console.log(chalk3.gray("  [O] Other (type custom model name)"));
+      console.log(chalk3.gray("  [C] Cancel\n"));
+      const input3 = (await ask(chalk3.cyan("Select model [number, name, C]: "))).trim();
+      if (!input3 || input3.toLowerCase() === "c") return;
+      const num = parseInt(input3, 10);
+      if (!isNaN(num) && num >= 1 && num <= list.length) {
+        targetModel = list[num - 1];
+      } else if (input3.toLowerCase() === "o") {
+        const custom = (await ask(chalk3.cyan("Enter model name: "))).trim();
+        if (!custom) return;
+        targetModel = custom;
+      } else {
+        targetModel = input3;
+      }
+    }
+    if (!this.apiKey) {
+      const resolved = resolveCredentials({ cliProvider: this.provider });
+      if (resolved.apiKey) {
+        this.apiKey = resolved.apiKey;
+      } else {
+        console.log(chalk3.yellow(`
+No API key found for ${this.provider.toUpperCase()}.`));
+        this.apiKey = (await ask(chalk3.cyan(`Enter API key for ${this.provider.toUpperCase()}: `))).trim();
+        if (!this.apiKey) {
+          console.log(chalk3.red("API key is required."));
+          return;
+        }
+      }
+    }
+    try {
+      this.model = createChatModel({
+        provider: this.provider,
+        model: targetModel,
+        apiKey: this.apiKey
+      });
+      this.modelName = targetModel;
+      this.agent = createDatabaseAgent({
+        adapter: this.adapter,
+        model: this.model,
+        classifierOptions: this.classifierOptions
+      });
+      console.log(chalk3.green(`
+Updated active model to: ${targetModel} [${this.provider}]
+`));
+    } catch (err) {
+      console.log(chalk3.red(`
+Failed to update model: ${err.message}
+`));
+    }
+  }
+  async handleProviderCommand(newProvider, ask) {
+    let p = newProvider.toLowerCase();
+    if (!["google", "openai", "anthropic"].includes(p)) {
+      console.log(chalk3.bold.cyan(`
+Current Provider: `) + chalk3.blue(this.provider));
+      console.log("Available providers:");
+      console.log("  [1] Google Gemini (google)");
+      console.log("  [2] OpenAI (openai)");
+      console.log("  [3] Anthropic (anthropic)");
+      console.log("  [C] Cancel\n");
+      const ans = (await ask(chalk3.cyan("Select provider [1-3, name, C]: "))).trim().toLowerCase();
+      if (!ans || ans === "c") return;
+      if (ans === "1" || ans === "google") p = "google";
+      else if (ans === "2" || ans === "openai") p = "openai";
+      else if (ans === "3" || ans === "anthropic") p = "anthropic";
+      else {
+        console.log(chalk3.red("Invalid provider."));
+        return;
+      }
+    }
+    const resolved = resolveCredentials({ cliProvider: p });
+    let key = resolved.apiKey;
+    if (!key) {
+      console.log(chalk3.yellow(`
+No API key found for ${p.toUpperCase()}.`));
+      key = (await ask(chalk3.cyan(`Enter API key for ${p.toUpperCase()}: `))).trim();
+      if (!key) {
+        console.log(chalk3.red("API key cannot be empty."));
+        return;
+      }
+      const save = (await ask(chalk3.cyan("Save this API key to ~/.sandal/config.json? (Y/n): "))).trim().toLowerCase();
+      if (save !== "n") {
+        if (p === "google") writeConfig({ geminiApiKey: key, defaultProvider: "google" });
+        else if (p === "openai") writeConfig({ openaiApiKey: key, defaultProvider: "openai" });
+        else if (p === "anthropic") writeConfig({ anthropicApiKey: key, defaultProvider: "anthropic" });
+      }
+    }
+    const defaultModel = getDefaultModelForProvider(p);
+    try {
+      this.model = createChatModel({
+        provider: p,
+        model: defaultModel,
+        apiKey: key
+      });
+      this.provider = p;
+      this.modelName = defaultModel;
+      this.apiKey = key;
+      this.agent = createDatabaseAgent({
+        adapter: this.adapter,
+        model: this.model,
+        classifierOptions: this.classifierOptions
+      });
+      console.log(
+        chalk3.green(`
+Switched provider to ${p.toUpperCase()} with model ${defaultModel}.
+`)
+      );
+    } catch (err) {
+      console.log(chalk3.red(`Failed to switch provider: ${err.message}
+`));
+    }
+  }
+  async handleKeyCommand(arg, ask) {
+    const sub = arg.toLowerCase().trim();
+    if (sub === "remove" || sub === "clear" || sub === "delete") {
+      const confirmAns = (await ask(chalk3.yellow(`Remove stored API key for provider "${this.provider}"? (y/N): `))).trim().toLowerCase();
+      if (confirmAns === "y" || confirmAns === "yes") {
+        removeApiKey(this.provider);
+        this.apiKey = void 0;
+        console.log(chalk3.green(`
+Removed stored API key for "${this.provider}" from ~/.sandal/config.json.`));
+        console.log(chalk3.gray(`Subsequent requests with this provider will prompt for a key.
+`));
+      }
+      return;
+    }
+    if (sub.startsWith("set")) {
+      let newKey = sub.replace(/^set\s*/, "").trim();
+      if (!newKey) {
+        newKey = (await ask(chalk3.cyan(`Enter new API key for ${this.provider}: `))).trim();
+      }
+      if (!newKey) {
+        console.log(chalk3.red("API key cannot be empty."));
+        return;
+      }
+      this.apiKey = newKey;
+      if (this.provider === "google") writeConfig({ geminiApiKey: newKey });
+      else if (this.provider === "openai") writeConfig({ openaiApiKey: newKey });
+      else if (this.provider === "anthropic") writeConfig({ anthropicApiKey: newKey });
+      this.model = createChatModel({
+        provider: this.provider,
+        model: this.modelName,
+        apiKey: newKey
+      });
+      this.agent = createDatabaseAgent({
+        adapter: this.adapter,
+        model: this.model,
+        classifierOptions: this.classifierOptions
+      });
+      console.log(chalk3.green(`
+Updated API key for "${this.provider}" and refreshed model.
+`));
+      return;
+    }
+    console.log(chalk3.bold.cyan("\nAPI Key Status:"));
+    console.log(`  Provider:   ${chalk3.blue(this.provider)}`);
+    console.log(`  Model:      ${chalk3.white(this.modelName)}`);
+    console.log(
+      `  Active Key: ${this.apiKey ? chalk3.yellow(maskApiKey(this.apiKey)) : chalk3.red("None (not set)")}`
+    );
+    console.log(chalk3.gray("\nUsage:"));
+    console.log(chalk3.gray("  .key remove         - Remove stored key from ~/.sandal/config.json"));
+    console.log(chalk3.gray("  .key set <api-key>  - Update API key on the fly\n"));
+  }
+  handleListChats() {
+    const list = this.memoryManager.listSessions();
+    if (list.length === 0) {
+      console.log(chalk3.yellow("\nNo saved chat sessions found.\n"));
+      return;
+    }
+    console.log(chalk3.bold.cyan("\nSaved Chat Sessions:"));
+    list.forEach((s, i) => {
+      const isActive = s.id === this.sessionId;
+      const activeMarker = isActive ? chalk3.green(" [ACTIVE]") : "";
+      const dateStr = new Date(s.updatedAt).toLocaleString();
+      console.log(
+        `  [${i + 1}] ${chalk3.bold(s.title)}${activeMarker}
+      ID: ${chalk3.gray(s.id)} | ${chalk3.yellow(s.messageCount + " messages")} | ${chalk3.gray(dateStr)}`
+      );
+    });
+    console.log(chalk3.gray("\nCommands: .chat <id|num> to switch, .new to start fresh chat\n"));
+  }
+  handleNewChat() {
+    const newSession = this.memoryManager.createSession("New Chat", this.adapter.connectionUrl);
+    this.sessionId = newSession.id;
+    this.agent = createDatabaseAgent({
+      adapter: this.adapter,
+      model: this.model,
+      classifierOptions: this.classifierOptions
+    });
+    console.log(chalk3.green(`
+Started fresh chat session: ${this.sessionId}`));
+    console.log(chalk3.gray("Chat memory is clean for this new session.\n"));
+  }
+  handleSwitchChat(arg) {
+    const list = this.memoryManager.listSessions();
+    let targetId;
+    const num = parseInt(arg, 10);
+    if (!isNaN(num) && num >= 1 && num <= list.length) {
+      targetId = list[num - 1].id;
+    } else {
+      const found = list.find(
+        (s) => s.id === arg || s.id.toLowerCase().includes(arg.toLowerCase())
+      );
+      if (found) targetId = found.id;
+    }
+    if (!targetId) {
+      console.log(chalk3.red(`
+Chat session "${arg}" not found. Use .chats to list sessions.
+`));
+      return;
+    }
+    const session = this.memoryManager.getSession(targetId);
+    if (!session) {
+      console.log(chalk3.red(`
+Could not load chat session "${targetId}".
+`));
+      return;
+    }
+    this.sessionId = session.id;
+    this.agent = createDatabaseAgent({
+      adapter: this.adapter,
+      model: this.model,
+      classifierOptions: this.classifierOptions
+    });
+    console.log(
+      chalk3.green(
+        `
+Switched to chat: "${session.title}" (${session.messages.length} messages in memory).
+`
+      )
+    );
+  }
+  handleShowHistory() {
+    const session = this.memoryManager.getSession(this.sessionId);
+    if (!session || session.messages.length === 0) {
+      console.log(chalk3.yellow(`
+No message history in current chat (${this.sessionId}).
+`));
+      return;
+    }
+    console.log(chalk3.bold.cyan(`
+Chat History: "${session.title}" [${this.sessionId}]:`));
+    console.log(chalk3.gray("\u2500".repeat(60)));
+    for (const msg of session.messages) {
+      const time = new Date(msg.timestamp).toLocaleTimeString();
+      if (msg.role === "user") {
+        console.log(`${chalk3.bold.blue("\u{1F464} User")} ${chalk3.gray(`(${time})`)}:
+  ${msg.content}`);
+      } else if (msg.role === "assistant") {
+        if (msg.query) {
+          console.log(`  ${chalk3.gray(`[Query: ${msg.query}]`)}`);
+        }
+        console.log(`${chalk3.bold.green("\u{1F916} Assistant")} ${chalk3.gray(`(${time})`)}:
+  ${msg.content}`);
+      }
+      console.log(chalk3.gray("\u2500".repeat(60)));
+    }
+    console.log("");
+  }
+  handleClearChat() {
+    this.memoryManager.clearSession(this.sessionId);
+    this.agent = createDatabaseAgent({
+      adapter: this.adapter,
+      model: this.model,
+      classifierOptions: this.classifierOptions
+    });
+    console.log(chalk3.green(`
+Chat memory for session [${this.sessionId}] has been cleared.
+`));
+  }
+  handleRenderMarkdown(arg) {
+    if (!arg) {
+      console.log(chalk3.yellow("Usage: .md <markdown text or file path>"));
+      console.log(chalk3.gray("Example: .md # Hello World"));
+      console.log(chalk3.gray("Example: .md ./README.md"));
+      return;
+    }
+    try {
+      if (fs3.existsSync(arg) && fs3.statSync(arg).isFile()) {
+        const fileContent = fs3.readFileSync(arg, "utf-8");
+        console.log("\n" + renderMarkdown(fileContent) + "\n");
+        return;
+      }
+    } catch {
+    }
+    console.log("\n" + renderMarkdown(arg) + "\n");
+  }
   renderRowsTable(queryResult) {
     const rows = queryResult.rows;
     if (!rows || rows.length === 0) {
-      console.log(chalk2.gray("(0 rows returned)"));
+      console.log(chalk3.gray("(0 rows returned)"));
       return;
     }
     const fields = queryResult.fields && queryResult.fields.length > 0 ? queryResult.fields : Object.keys(rows[0] || {});
     if (fields.length === 0) return;
     const displayRows = rows.slice(0, 25);
     const table = new Table({
-      head: fields.map((f) => chalk2.cyan.bold(f)),
+      head: fields.map((f) => chalk3.cyan.bold(f)),
       style: { head: [], border: ["gray"] }
     });
     for (const r of displayRows) {
       table.push(
         fields.map((f) => {
           const val = r[f];
-          if (val === null || val === void 0) return chalk2.gray("NULL");
+          if (val === null || val === void 0) return chalk3.gray("NULL");
           if (typeof val === "object") {
             try {
               return JSON.stringify(val);
@@ -2119,94 +2928,99 @@ ${chalk2.gray(
     }
     console.log(table.toString());
     if (rows.length > 25) {
-      console.log(chalk2.yellow(`Showing first 25 of ${rows.length.toLocaleString()} rows.`));
+      console.log(chalk3.yellow(`Showing first 25 of ${rows.length.toLocaleString()} rows.`));
     }
     console.log(
-      chalk2.gray(
-        `Total rows: ${queryResult.rowCount ?? rows.length} | Duration: ${queryResult.durationMs ?? 0}ms`
+      chalk3.gray(
+        `Total rows: ${queryResult.rowCount ?? rows.length} | Execution duration: ${queryResult.durationMs}ms
+`
       )
     );
   }
   async handleListEntities() {
-    const spinner = ora(chalk2.blue("Loading schema...")).start();
+    const spinner = ora(chalk3.blue("Inspecting schema...")).start();
     try {
-      const schema = await this.adapter.inspectSchema();
+      const schema = await this.adapter.inspectSchema(false);
       spinner.stop();
       if (schema.type === "postgres") {
         const tables = schema.tables || [];
         if (tables.length === 0) {
-          console.log(chalk2.yellow("No tables found in public schema."));
+          console.log(chalk3.yellow("No tables found in public schema."));
           return;
         }
-        console.log(chalk2.bold.cyan(`
+        console.log(chalk3.bold.cyan(`
 Tables in "${schema.databaseName}":`));
         for (const t of tables) {
           console.log(
-            `  \u2022 ${chalk2.white.bold(t.schema + "." + t.name)} (~${(t.approximateRowCount ?? 0).toLocaleString()} rows, ${t.columns.length} columns)`
+            `  \u2022 ${chalk3.bold(t.name)} ${chalk3.gray(`(~${t.approximateRowCount ?? 0} rows, ${t.columns.length} columns)`)}`
           );
         }
         console.log("");
       } else {
         const collections = schema.collections || [];
         if (collections.length === 0) {
-          console.log(chalk2.yellow("No collections found."));
+          console.log(chalk3.yellow("No collections found."));
           return;
         }
-        console.log(chalk2.bold.cyan(`
+        console.log(chalk3.bold.cyan(`
 Collections in "${schema.databaseName}":`));
         for (const c of collections) {
           console.log(
-            `  \u2022 ${chalk2.white.bold(c.name)} (~${(c.documentCount ?? 0).toLocaleString()} documents, ${c.fields.length} inferred fields)`
+            `  \u2022 ${chalk3.bold(c.name)} ${chalk3.gray(`(${c.documentCount ?? 0} docs, ${c.fields.length} sampled fields)`)}`
           );
         }
         console.log("");
       }
     } catch (err) {
-      spinner.fail(chalk2.red(`Failed to fetch entities: ${err.message}`));
+      spinner.fail(chalk3.red(`Failed to list entities: ${err.message}`));
     }
   }
   async handleShowSchema(entityName) {
-    const spinner = ora(chalk2.blue("Loading schema details...")).start();
+    const spinner = ora(chalk3.blue("Fetching schema details...")).start();
     try {
-      const schema = await this.adapter.inspectSchema();
+      const schema = await this.adapter.inspectSchema(false);
       spinner.stop();
       if (!entityName) {
         console.log("\n" + formatSchemaForPrompt(schema) + "\n");
         return;
       }
       if (schema.type === "postgres") {
-        const table = schema.tables?.find(
-          (t) => t.name.toLowerCase() === entityName.toLowerCase() || `${t.schema}.${t.name}`.toLowerCase() === entityName.toLowerCase()
+        const table = (schema.tables || []).find(
+          (t) => t.name.toLowerCase() === entityName.toLowerCase()
         );
         if (!table) {
-          console.log(chalk2.red(`Table "${entityName}" not found.`));
+          console.log(chalk3.red(`Table "${entityName}" not found.`));
           return;
         }
-        console.log(chalk2.bold.cyan(`
+        console.log(chalk3.bold.cyan(`
 Schema for table: ${table.schema}.${table.name}`));
         const tableDetails = new Table({
-          head: ["Column", "Type", "Nullable", "Default", "Primary Key"].map((h) => chalk2.cyan.bold(h))
+          head: ["Column", "Data Type", "Nullable", "Primary Key", "Default"].map(
+            (h) => chalk3.cyan.bold(h)
+          )
         });
-        for (const col of table.columns) {
+        for (const c of table.columns) {
           tableDetails.push([
-            col.name,
-            col.dataType,
-            col.isNullable ? "YES" : "NO",
-            col.defaultValue || "-",
-            col.isPrimaryKey ? "PK" : ""
+            c.name,
+            c.dataType,
+            c.isNullable ? "YES" : "NO",
+            c.isPrimaryKey ? chalk3.green("YES") : "NO",
+            c.defaultValue ?? chalk3.gray("NULL")
           ]);
         }
         console.log(tableDetails.toString());
       } else {
-        const collection = schema.collections?.find((c) => c.name.toLowerCase() === entityName.toLowerCase());
+        const collection = (schema.collections || []).find(
+          (c) => c.name.toLowerCase() === entityName.toLowerCase()
+        );
         if (!collection) {
-          console.log(chalk2.red(`Collection "${entityName}" not found.`));
+          console.log(chalk3.red(`Collection "${entityName}" not found.`));
           return;
         }
-        console.log(chalk2.bold.cyan(`
+        console.log(chalk3.bold.cyan(`
 Schema for collection: ${collection.name}`));
         const colDetails = new Table({
-          head: ["Field", "Inferred Types"].map((h) => chalk2.cyan.bold(h))
+          head: ["Field", "Inferred Types"].map((h) => chalk3.cyan.bold(h))
         });
         for (const f of collection.fields) {
           colDetails.push([f.name, f.types.join(", ")]);
@@ -2214,21 +3028,22 @@ Schema for collection: ${collection.name}`));
         console.log(colDetails.toString());
       }
     } catch (err) {
-      spinner.fail(chalk2.red(`Failed to inspect schema: ${err.message}`));
+      spinner.fail(chalk3.red(`Failed to inspect schema: ${err.message}`));
     }
   }
   printWelcomeBanner() {
     const banner = [
-      chalk2.bold.cyan("SANDAL: Safe Agentic Natural-language Database Access Layer"),
-      chalk2.gray("LangGraph + Multi-Provider AI (Gemini, OpenAI, Anthropic)"),
+      chalk3.bold.cyan("SANDAL: Safe Agentic Natural-language Database Access Layer"),
+      chalk3.gray("LangGraph + Multi-Provider AI (Gemini, OpenAI, Anthropic)"),
       "",
-      `${chalk2.bold("Database:")} ${chalk2.green(this.adapter.type.toUpperCase())} (${this.adapter.getMaskedUrl()})`,
-      `${chalk2.bold("LLM Provider:")} ${chalk2.blue(this.provider)} [${chalk2.white(this.modelName)}]`,
-      `${chalk2.bold("Strict Mode:")} ${this.strictMode ? chalk2.green("ON (Full wipes blocked)") : chalk2.yellow("OFF")}`,
-      `${chalk2.bold("Allow Full Wipe:")} ${this.allowFullWipe ? chalk2.red("ENABLED") : chalk2.gray("NO")}`,
+      `${chalk3.bold("Database:")}      ${chalk3.green(this.adapter.type.toUpperCase())} (${this.adapter.getMaskedUrl()})`,
+      `${chalk3.bold("LLM Provider:")}  ${chalk3.blue(this.provider)} [${chalk3.white(this.modelName)}]`,
+      `${chalk3.bold("Chat Session:")}  ${chalk3.yellow(this.sessionId)}`,
+      `${chalk3.bold("Strict Mode:")}   ${this.strictMode ? chalk3.green("ON (Full wipes blocked)") : chalk3.yellow("OFF")}`,
+      `${chalk3.bold("Markdown:")}      ${this.renderMarkdown ? chalk3.green("ENABLED") : chalk3.gray("DISABLED")}`,
       "",
-      chalk2.gray("Type your natural language request or SQL/Mongo query."),
-      chalk2.gray("Commands: .tables, .schema [name], .refresh, .help, exit")
+      chalk3.gray("Type your natural language request or SQL/Mongo query."),
+      chalk3.gray("Commands: .connect, .model, .chats, .new, .history, .key, .help, exit")
     ].join("\n");
     console.log(
       boxen2(banner, {
@@ -2243,20 +3058,30 @@ Schema for collection: ${collection.name}`));
     console.log(
       boxen2(
         [
-          chalk2.bold.cyan("SANDAL REPL Commands:"),
+          chalk3.bold.cyan("SANDAL REPL Commands:"),
           "",
-          `${chalk2.bold(".tables / .collections")}   List all tables or collections with row counts`,
-          `${chalk2.bold(".schema [name]")}           Show columns, types, and indexes for a table`,
-          `${chalk2.bold(".refresh")}                 Force refresh cached schema introspection`,
-          `${chalk2.bold(".clear")}                   Clear terminal screen`,
-          `${chalk2.bold(".help")}                    Display this command reference`,
-          `${chalk2.bold("exit / quit")}              Gracefully disconnect and exit`,
+          `${chalk3.bold(".tables / .collections")}   List all tables or collections with row counts`,
+          `${chalk3.bold(".schema [name]")}           Show columns, types, and indexes for a table`,
+          `${chalk3.bold(".connect / .switch")}       Switch database connection (shows saved connections)`,
+          `${chalk3.bold(".model [name]")}            Change active LLM model on the fly`,
+          `${chalk3.bold(".provider [name]")}         Switch LLM provider (google, openai, anthropic)`,
+          `${chalk3.bold(".key [remove | set]")}      View, remove, or update API key`,
+          `${chalk3.bold(".chats")}                   List saved chat sessions`,
+          `${chalk3.bold(".chat <id | num>")}         Switch to another chat session`,
+          `${chalk3.bold(".new")}                     Start a fresh chat session with clear memory`,
+          `${chalk3.bold(".history")}                 Show conversation history for current chat`,
+          `${chalk3.bold(".clear-chat")}              Clear memory for current chat`,
+          `${chalk3.bold(".md [file | text]")}        Render markdown file or text in terminal`,
+          `${chalk3.bold(".refresh")}                 Force refresh cached schema introspection`,
+          `${chalk3.bold(".clear")}                   Clear terminal screen`,
+          `${chalk3.bold(".help")}                    Display this command reference`,
+          `${chalk3.bold("exit / quit")}              Gracefully disconnect and exit`,
           "",
-          chalk2.bold.yellow("Example Natural Language Requests:"),
+          chalk3.bold.yellow("Example Natural Language Requests:"),
           '  "Show top 10 users signed up in the last 30 days"',
+          '  "Now count how many of them are active" (multi-turn follow-up)',
           '  "Calculate total revenue grouped by product category"',
-          '  "Add a concurrent index on orders(created_at)"',
-          '  "Delete users where status is inactive"'
+          '  "Add a concurrent index on orders(created_at)"'
         ].join("\n"),
         {
           padding: 1,
@@ -2283,13 +3108,35 @@ Schema for collection: ${collection.name}`));
       } catch {
       }
     }
-    console.log(chalk2.cyan("\nDatabase connection closed. Goodbye! \u{1F44B}\n"));
+    console.log(chalk3.cyan("\nDatabase connection closed. Goodbye! \u{1F44B}\n"));
   }
 };
 
 // src/cli.ts
 var program = new Command();
-program.name("sandal-db").description("SANDAL - Safe Agentic Natural-language Database Access Layer").version("1.0.0").argument("[dbUrl]", "Database connection URL (PostgreSQL or MongoDB)").option("-p, --provider <provider>", "LLM provider: google | openai | anthropic").option("-m, --model <model>", "LLM model name (e.g. gemini-2.5-flash, gpt-4o, claude-3-5-sonnet-latest)").option("-k, --key <key>", "API key for the chosen LLM provider").option("--strict", "Strict safety mode: hard-blocks full database wipes (default: true)", true).option("--no-strict", "Disable strict safety mode").option("--allow-full-wipe", "Explicitly allow full database / all-table wipe queries with confirmation", false).option("--threshold <number>", "Row count threshold for classifying updates as dangerous", "50").action(async (cliDbUrl, options) => {
+program.name("sandal-db").description("SANDAL - Safe Agentic Natural-language Database Access Layer").version("1.0.0").argument("[dbUrl]", "Database connection URL (PostgreSQL or MongoDB)").option(
+  "-p, --provider <provider>",
+  "LLM provider: google | openai | anthropic"
+).option(
+  "-m, --model <model>",
+  "LLM model name (e.g. gemini-2.5-flash, gpt-4o, claude-3-5-sonnet-latest)"
+).option("-k, --key <key>", "API key for the chosen LLM provider").option(
+  "--strict",
+  "Strict safety mode: hard-blocks full database wipes (default: true)",
+  true
+).option("--no-strict", "Disable strict safety mode").option(
+  "--allow-full-wipe",
+  "Explicitly allow full database / all-table wipe queries with confirmation",
+  false
+).option(
+  "--threshold <number>",
+  "Row count threshold for classifying updates as dangerous",
+  "50"
+).option(
+  "--markdown",
+  "Render LLM answers formatted as terminal markdown (default: true)",
+  true
+).option("--no-markdown", "Disable terminal markdown rendering").action(async (cliDbUrl, options) => {
   try {
     await runCli({
       cliDbUrl,
@@ -2298,61 +3145,145 @@ program.name("sandal-db").description("SANDAL - Safe Agentic Natural-language Da
       cliApiKey: options.key,
       strictMode: options.strict !== false,
       allowFullWipe: Boolean(options.allowFullWipe),
-      rowThreshold: parseInt(options.threshold, 10) || 50
+      rowThreshold: parseInt(options.threshold, 10) || 50,
+      renderMarkdown: options.markdown !== false
     });
   } catch (err) {
-    console.error(chalk3.red(`
+    console.error(chalk4.red(`
 Error: ${err.message}`));
     process.exit(1);
   }
 });
-var configCmd = program.command("config").description("Manage stored database credentials and API keys in ~/.sandal/config.json").option("--set-db <url>", "Set default database connection URL").option("--set-key <key>", "Set API key for the default provider").option("--set-gemini <key>", "Set Google Gemini API key").option("--set-openai <key>", "Set OpenAI API key").option("--set-anthropic <key>", "Set Anthropic API key").option("--set-provider <provider>", "Set default LLM provider (google | openai | anthropic)").option("--set-model <model>", "Set default model name").option("--show", "Display current stored configuration (with masked secrets)").option("--path", "Print the path to the configuration file").action((opts) => {
+var configCmd = program.command("config").description(
+  "Manage stored database credentials and API keys in ~/.sandal/config.json"
+).option("--set-db <url>", "Set default database connection URL").option("--set-key <key>", "Set API key for the default provider").option("--set-gemini <key>", "Set Google Gemini API key").option("--set-openai <key>", "Set OpenAI API key").option("--set-anthropic <key>", "Set Anthropic API key").option(
+  "--set-provider <provider>",
+  "Set default LLM provider (google | openai | anthropic)"
+).option("--set-model <model>", "Set default model name").option(
+  "--set-markdown <boolean>",
+  "Enable or disable default terminal markdown rendering (true | false)"
+).option(
+  "--remove-key [provider]",
+  "Remove stored API key for a provider (google | openai | anthropic | all)"
+).option(
+  "--connections",
+  "List all saved database connections"
+).option(
+  "--remove-connection <target>",
+  "Remove a saved database connection by URL or index"
+).option(
+  "--show",
+  "Display current stored configuration (with masked secrets)"
+).option("--path", "Print the path to the configuration file").action((opts) => {
   if (opts.path) {
     console.log(getConfigFilePath());
     return;
   }
+  if (opts.connections) {
+    const list = getSavedConnections();
+    if (list.length === 0) {
+      console.log(chalk4.yellow("\nNo saved database connections found.\n"));
+    } else {
+      console.log(chalk4.bold.cyan("\nSaved Database Connections:"));
+      list.forEach((url, i) => {
+        console.log(`  [${i + 1}] ${maskUrl(url)}`);
+      });
+      console.log("");
+    }
+    return;
+  }
+  if (opts.removeConnection) {
+    const removed = removeSavedConnection(opts.removeConnection);
+    if (removed) {
+      console.log(chalk4.green(`Removed connection from saved history.`));
+    } else {
+      console.log(chalk4.red(`Connection "${opts.removeConnection}" not found in history.`));
+    }
+    return;
+  }
+  if (opts.removeKey !== void 0) {
+    const prov = typeof opts.removeKey === "string" && opts.removeKey.trim() ? opts.removeKey.toLowerCase() : "all";
+    removeApiKey(prov);
+    console.log(chalk4.green(`Removed API key for "${prov}" from ~/.sandal/config.json.`));
+    return;
+  }
   if (opts.show) {
     const cfg = readConfig();
-    console.log(chalk3.bold.cyan("\nSaved Configuration (~/.sandal/config.json):"));
-    console.log(`  Database URL:     ${cfg.dbUrl ? chalk3.green(maskUrl(cfg.dbUrl)) : chalk3.gray("Not set")}`);
-    console.log(`  Default Provider: ${cfg.defaultProvider ? chalk3.blue(cfg.defaultProvider) : chalk3.gray("Not set (defaults to google)")}`);
-    console.log(`  Default Model:    ${cfg.defaultModel ? chalk3.white(cfg.defaultModel) : chalk3.gray("Default for provider")}`);
-    console.log(`  Gemini Key:       ${cfg.geminiApiKey ? chalk3.yellow(maskApiKey(cfg.geminiApiKey)) : chalk3.gray("Not set")}`);
-    console.log(`  OpenAI Key:       ${cfg.openaiApiKey ? chalk3.yellow(maskApiKey(cfg.openaiApiKey)) : chalk3.gray("Not set")}`);
-    console.log(`  Anthropic Key:    ${cfg.anthropicApiKey ? chalk3.yellow(maskApiKey(cfg.anthropicApiKey)) : chalk3.gray("Not set")}
-`);
+    const saved = getSavedConnections();
+    console.log(
+      chalk4.bold.cyan("\nSaved Configuration (~/.sandal/config.json):")
+    );
+    console.log(
+      `  Database URL:       ${cfg.dbUrl ? chalk4.green(maskUrl(cfg.dbUrl)) : chalk4.gray("Not set")}`
+    );
+    console.log(
+      `  Default Provider:   ${cfg.defaultProvider ? chalk4.blue(cfg.defaultProvider) : chalk4.gray("Not set (defaults to google)")}`
+    );
+    console.log(
+      `  Default Model:      ${cfg.defaultModel ? chalk4.white(cfg.defaultModel) : chalk4.gray("Default for provider")}`
+    );
+    console.log(
+      `  Markdown Rendering: ${cfg.renderMarkdown !== false ? chalk4.green("enabled") : chalk4.yellow("disabled")}`
+    );
+    console.log(
+      `  Saved Connections:  ${saved.length > 0 ? chalk4.cyan(`${saved.length} connection(s)`) : chalk4.gray("None")}`
+    );
+    console.log(
+      `  Gemini Key:         ${cfg.geminiApiKey ? chalk4.yellow(maskApiKey(cfg.geminiApiKey)) : chalk4.gray("Not set")}`
+    );
+    console.log(
+      `  OpenAI Key:         ${cfg.openaiApiKey ? chalk4.yellow(maskApiKey(cfg.openaiApiKey)) : chalk4.gray("Not set")}`
+    );
+    console.log(
+      `  Anthropic Key:      ${cfg.anthropicApiKey ? chalk4.yellow(maskApiKey(cfg.anthropicApiKey)) : chalk4.gray("Not set")}
+`
+    );
     return;
   }
   const updates = {};
   if (opts.setDb) {
     detectDatabaseType(opts.setDb);
     updates.dbUrl = opts.setDb;
-    console.log(chalk3.green(`Updated default database URL: ${maskUrl(opts.setDb)}`));
+    addSavedConnection(opts.setDb);
+    console.log(
+      chalk4.green(`Updated default database URL: ${maskUrl(opts.setDb)}`)
+    );
   }
   if (opts.setProvider) {
     const p = opts.setProvider.toLowerCase();
     if (!["google", "openai", "anthropic"].includes(p)) {
-      console.error(chalk3.red("Invalid provider. Expected google, openai, or anthropic."));
+      console.error(
+        chalk4.red("Invalid provider. Expected google, openai, or anthropic.")
+      );
       process.exit(1);
     }
     updates.defaultProvider = p;
-    console.log(chalk3.green(`Updated default provider: ${p}`));
+    console.log(chalk4.green(`Updated default provider: ${p}`));
   }
   if (opts.setModel) {
     updates.defaultModel = opts.setModel;
-    console.log(chalk3.green(`Updated default model: ${opts.setModel}`));
+    console.log(chalk4.green(`Updated default model: ${opts.setModel}`));
+  }
+  if (opts.setMarkdown !== void 0) {
+    const val = opts.setMarkdown.toLowerCase() === "true" || opts.setMarkdown === "1" || opts.setMarkdown === "yes";
+    updates.renderMarkdown = val;
+    console.log(
+      chalk4.green(
+        `Updated default markdown rendering: ${val ? "enabled" : "disabled"}.`
+      )
+    );
   }
   if (opts.setGemini) {
     updates.geminiApiKey = opts.setGemini;
-    console.log(chalk3.green("Updated Gemini API key."));
+    console.log(chalk4.green("Updated Gemini API key."));
   }
   if (opts.setOpenai) {
     updates.openaiApiKey = opts.setOpenai;
-    console.log(chalk3.green("Updated OpenAI API key."));
+    console.log(chalk4.green("Updated OpenAI API key."));
   }
   if (opts.setAnthropic) {
     updates.anthropicApiKey = opts.setAnthropic;
-    console.log(chalk3.green("Updated Anthropic API key."));
+    console.log(chalk4.green("Updated Anthropic API key."));
   }
   if (opts.setKey) {
     const current = readConfig();
@@ -2360,16 +3291,53 @@ var configCmd = program.command("config").description("Manage stored database cr
     if (prov === "google") updates.geminiApiKey = opts.setKey;
     else if (prov === "openai") updates.openaiApiKey = opts.setKey;
     else if (prov === "anthropic") updates.anthropicApiKey = opts.setKey;
-    console.log(chalk3.green(`Updated API key for provider "${prov}".`));
+    console.log(chalk4.green(`Updated API key for provider "${prov}".`));
   }
   if (Object.keys(updates).length > 0) {
     writeConfig(updates);
-    console.log(chalk3.gray(`Saved to ${getConfigFilePath()}`));
+    console.log(chalk4.gray(`Saved to ${getConfigFilePath()}`));
   } else {
     configCmd.help();
   }
 });
+program.command("markdown [fileOrText]").alias("md").description("Render markdown text or a markdown file directly in the terminal").option("-w, --width <width>", "Wrap width in columns").option("--no-prefix", "Hide heading section prefixes").action(async (fileOrText, opts) => {
+  let content = fileOrText;
+  if (!content) {
+    if (!process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(Buffer.from(chunk));
+      }
+      content = Buffer.concat(chunks).toString("utf-8");
+    } else {
+      console.log(
+        chalk4.yellow(
+          "\nUsage: sandal md <file | text> or pipe markdown to sandal md"
+        )
+      );
+      console.log(chalk4.gray("Example: sandal md README.md"));
+      console.log(chalk4.gray('Example: sandal md "# Hello World"'));
+      console.log(chalk4.gray("Example: cat notes.md | sandal md\n"));
+      return;
+    }
+  } else {
+    try {
+      if (fs4.existsSync(content) && fs4.statSync(content).isFile()) {
+        content = fs4.readFileSync(content, "utf-8");
+      }
+    } catch {
+    }
+  }
+  const width = opts.width ? parseInt(opts.width, 10) : void 0;
+  const rendered = renderMarkdown(content, {
+    width,
+    showSectionPrefix: opts.prefix !== false
+  });
+  console.log("\n" + rendered + "\n");
+});
 async function runCli(opts) {
+  const config = readConfig();
+  const shouldRenderMarkdown = opts.renderMarkdown !== void 0 ? opts.renderMarkdown : config.renderMarkdown !== false;
   let resolved = resolveCredentials({
     cliDbUrl: opts.cliDbUrl,
     cliProvider: opts.cliProvider,
@@ -2378,7 +3346,11 @@ async function runCli(opts) {
   });
   let dbUrl = resolved.dbUrl;
   if (!dbUrl) {
-    console.log(chalk3.yellow("\nNo database connection URL found in CLI flags, environment, or config."));
+    console.log(
+      chalk4.yellow(
+        "\nNo database connection URL found in CLI flags, environment, or config."
+      )
+    );
     dbUrl = await input2({
       message: "Enter your database URL (postgres://... or mongodb://...):",
       validate: (val) => {
@@ -2406,7 +3378,7 @@ async function runCli(opts) {
   let provider = resolved.provider;
   let apiKey = resolved.apiKey;
   if (!apiKey) {
-    console.log(chalk3.yellow("\nNo API key found in environment or config."));
+    console.log(chalk4.yellow("\nNo API key found in environment or config."));
     provider = await select({
       message: "Select your LLM provider:",
       choices: [
@@ -2424,19 +3396,29 @@ async function runCli(opts) {
       default: true
     });
     if (saveKey) {
-      if (provider === "google") writeConfig({ geminiApiKey: apiKey, defaultProvider: "google" });
-      else if (provider === "openai") writeConfig({ openaiApiKey: apiKey, defaultProvider: "openai" });
-      else if (provider === "anthropic") writeConfig({ anthropicApiKey: apiKey, defaultProvider: "anthropic" });
+      if (provider === "google")
+        writeConfig({ geminiApiKey: apiKey, defaultProvider: "google" });
+      else if (provider === "openai")
+        writeConfig({ openaiApiKey: apiKey, defaultProvider: "openai" });
+      else if (provider === "anthropic")
+        writeConfig({ anthropicApiKey: apiKey, defaultProvider: "anthropic" });
     }
   }
   const modelName = opts.cliModel || resolved.model || getDefaultModelForProvider(provider);
-  const dbSpinner = ora2(`Connecting to database (${maskUrl(dbUrl)})...`).start();
+  const dbSpinner = ora2(
+    `Connecting to database (${maskUrl(dbUrl)})...`
+  ).start();
   const adapter = createDatabaseAdapter(dbUrl);
   try {
     await adapter.connect();
-    dbSpinner.succeed(chalk3.green(`Connected to ${adapter.type.toUpperCase()} database: ${adapter.databaseName}`));
+    dbSpinner.succeed(
+      chalk4.green(
+        `Connected to ${adapter.type.toUpperCase()} database: ${adapter.databaseName}`
+      )
+    );
+    addSavedConnection(dbUrl);
   } catch (err) {
-    dbSpinner.fail(chalk3.red(`Failed to connect to database: ${err.message}`));
+    dbSpinner.fail(chalk4.red(`Failed to connect to database: ${err.message}`));
     process.exit(1);
   }
   const model = createChatModel({
@@ -2449,9 +3431,11 @@ async function runCli(opts) {
     model,
     provider,
     modelName,
+    apiKey,
     strictMode: opts.strictMode,
     allowFullWipe: opts.allowFullWipe,
-    rowThreshold: opts.rowThreshold
+    rowThreshold: opts.rowThreshold,
+    renderMarkdown: shouldRenderMarkdown
   });
   await repl.start();
 }