neural-loom 0.2.48 → 0.2.49

package/src/app/components/IdeLayout.tsx

@@ -4,6 +4,7 @@ import { useEffect, useState, useCallback } from "react";
 import TerminalConsole from "./TerminalConsole";
 import DirectoryBrowserModal from "./DirectoryBrowserModal";
 import MarkdownPreview from "./MarkdownPreview";
+import DbExplorer from "./DbExplorer";
 
 interface FileNode {
   name: string;
@@ -156,7 +157,7 @@ export default function IdeLayout({ sessionId, workspaceRoot, scopedDirs, onClos
 
   const [editorMode, setEditorMode] = useState<'edit' | 'split' | 'preview'>('edit');
   const [explorerVisible, setExplorerVisible] = useState(true);
-  const [activeTab, setActiveTab] = useState<"explorer" | "git" | "analytics" | "auditor" | "browser">("explorer");
+  const [activeTab, setActiveTab] = useState<"explorer" | "git" | "analytics" | "auditor" | "browser" | "database">("explorer");
   const [browserUrlInput, setBrowserUrlInput] = useState("http://localhost:3000");
   const [isRefreshing, setIsRefreshing] = useState(false);
 
@@ -1008,6 +1009,26 @@ export default function IdeLayout({ sessionId, workspaceRoot, scopedDirs, onClos
           >
             🌐
           </div>
+
+          {/* Database Explorer Tab */}
+          <div
+            onClick={() => {
+              if (activeTab === "database") {
+                setExplorerVisible(!explorerVisible);
+              } else {
+                setActiveTab("database");
+                setExplorerVisible(true);
+              }
+            }}
+            style={{
+              ...sidebarIconStyle,
+              backgroundColor: activeTab === "database" && explorerVisible ? "rgba(255,255,255,0.08)" : "transparent",
+              borderLeft: activeTab === "database" && explorerVisible ? "2px solid var(--primary)" : "2px solid transparent",
+            }}
+            title="Database Explorer & SQL Client"
+          >
+            🗄️
+          </div>
         </div>
 
         <div
@@ -1030,6 +1051,7 @@ export default function IdeLayout({ sessionId, workspaceRoot, scopedDirs, onClos
               {activeTab === "analytics" && "Telemetry & Cost"}
               {activeTab === "auditor" && "Session Auditor"}
               {activeTab === "browser" && "Browser Preview"}
+              {activeTab === "database" && "Database Explorer"}
             </span>
             {activeTab === "explorer" && (
               <div style={{ display: "flex", gap: "0.25rem" }}>
@@ -1591,6 +1613,10 @@ export default function IdeLayout({ sessionId, workspaceRoot, scopedDirs, onClos
                 </div>
               </div>
             )}
+
+            {activeTab === "database" && (
+              <DbExplorer workspaceRoot={workspaceRoot} />
+            )}
           </div>
         </div>
         <div

package/src/lib/sql/ConnectionManager.ts

@@ -0,0 +1,207 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import fs from "fs";
+import path from "path";
+import { getConfigDir } from "../config";
+import { DbAdapter } from "./DbAdapter";
+import { SqliteAdapter } from "./adapters/SqliteAdapter";
+import { PostgresAdapter } from "./adapters/PostgresAdapter";
+import { MysqlAdapter } from "./adapters/MysqlAdapter";
+
+export interface DbConnectionProfile {
+  id: string;
+  name: string;
+  type: "sqlite" | "postgres" | "mysql";
+  filepath?: string; // sqlite
+  host?: string; // pg, mysql
+  port?: number; // pg, mysql
+  database?: string; // pg, mysql
+  username?: string; // pg, mysql
+  password?: string; // pg, mysql
+  ssl?: boolean; // pg
+  readOnly?: boolean;
+}
+
+export interface SqlConfigSchema {
+  connections: { [id: string]: DbConnectionProfile };
+  activeConnection: string | null;
+}
+
+export class ConnectionManager {
+  private static activeInstances = new Map<string, DbAdapter>();
+
+  private static getGlobalConfigPath(): string {
+    return path.join(getConfigDir(), "global-sql.json");
+  }
+
+  private static getWorkspaceConfigPath(workspaceRoot?: string): string | null {
+    if (!workspaceRoot) return null;
+    return path.join(workspaceRoot, ".ai", "neural-loom", "sql-config.json");
+  }
+
+  private static loadConfig(filePath: string): SqlConfigSchema {
+    try {
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, "utf8");
+        return JSON.parse(content);
+      }
+    } catch (err) {
+      console.error(`[ConnectionManager] Failed to load config from ${filePath}:`, err);
+    }
+    return { connections: {}, activeConnection: null };
+  }
+
+  private static saveConfig(filePath: string, config: SqlConfigSchema): void {
+    try {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(filePath, JSON.stringify(config, null, 2), "utf8");
+    } catch (err) {
+      console.error(`[ConnectionManager] Failed to save config to ${filePath}:`, err);
+    }
+  }
+
+  public static async getProfiles(workspaceRoot?: string): Promise<{
+    global: DbConnectionProfile[];
+    workspace: DbConnectionProfile[];
+    activeId: string | null;
+    isActiveGlobal: boolean;
+  }> {
+    const globalConfig = this.loadConfig(this.getGlobalConfigPath());
+    const globalProfiles = Object.values(globalConfig.connections);
+    
+    let workspaceProfiles: DbConnectionProfile[] = [];
+    let activeId = globalConfig.activeConnection;
+    let isActiveGlobal = true;
+
+    if (workspaceRoot) {
+      const wsConfigPath = this.getWorkspaceConfigPath(workspaceRoot);
+      if (wsConfigPath) {
+        const wsConfig = this.loadConfig(wsConfigPath);
+        workspaceProfiles = Object.values(wsConfig.connections);
+        if (wsConfig.activeConnection) {
+          activeId = wsConfig.activeConnection;
+          isActiveGlobal = false;
+        }
+      }
+    }
+
+    return {
+      global: globalProfiles,
+      workspace: workspaceProfiles,
+      activeId,
+      isActiveGlobal
+    };
+  }
+
+  public static async saveProfile(
+    profile: DbConnectionProfile,
+    isGlobal: boolean,
+    workspaceRoot?: string
+  ): Promise<void> {
+    const filePath = isGlobal 
+      ? this.getGlobalConfigPath() 
+      : this.getWorkspaceConfigPath(workspaceRoot);
+
+    if (!filePath) {
+      throw new Error("Invalid workspace root path for saving connection profile.");
+    }
+
+    const config = this.loadConfig(filePath);
+    config.connections[profile.id] = profile;
+    this.saveConfig(filePath, config);
+  }
+
+  public static async deleteProfile(
+    profileId: string,
+    isGlobal: boolean,
+    workspaceRoot?: string
+  ): Promise<void> {
+    const filePath = isGlobal 
+      ? this.getGlobalConfigPath() 
+      : this.getWorkspaceConfigPath(workspaceRoot);
+
+    if (!filePath) {
+      throw new Error("Invalid workspace root path for deleting connection profile.");
+    }
+
+    const config = this.loadConfig(filePath);
+    if (config.connections[profileId]) {
+      delete config.connections[profileId];
+      if (config.activeConnection === profileId) {
+        config.activeConnection = null;
+      }
+      this.saveConfig(filePath, config);
+    }
+
+    // Close any active instance
+    const cacheKey = `${isGlobal ? "global" : "ws"}:${profileId}`;
+    const active = this.activeInstances.get(cacheKey);
+    if (active) {
+      await active.disconnect().catch(console.error);
+      this.activeInstances.delete(cacheKey);
+    }
+  }
+
+  public static async setActiveProfile(
+    profileId: string | null,
+    isGlobal: boolean,
+    workspaceRoot?: string
+  ): Promise<void> {
+    const filePath = isGlobal 
+      ? this.getGlobalConfigPath() 
+      : this.getWorkspaceConfigPath(workspaceRoot);
+
+    if (!filePath) {
+      throw new Error("Invalid workspace root path for setting active profile.");
+    }
+
+    const config = this.loadConfig(filePath);
+    config.activeConnection = profileId;
+    this.saveConfig(filePath, config);
+  }
+
+  public static createAdapter(profile: DbConnectionProfile, workspaceRoot?: string): DbAdapter {
+    switch (profile.type) {
+      case "sqlite":
+        return new SqliteAdapter(profile, workspaceRoot);
+      case "postgres":
+        return new PostgresAdapter(profile);
+      case "mysql":
+        return new MysqlAdapter(profile);
+      default:
+        throw new Error(`Unsupported database type: ${(profile as any).type}`);
+    }
+  }
+
+  public static async getActiveAdapter(workspaceRoot?: string): Promise<{ adapter: DbAdapter; profile: DbConnectionProfile } | null> {
+    const { global, workspace, activeId, isActiveGlobal } = await this.getProfiles(workspaceRoot);
+    if (!activeId) return null;
+
+    const cacheKey = `${isActiveGlobal ? "global" : "ws"}:${activeId}`;
+    const cached = this.activeInstances.get(cacheKey);
+    if (cached) {
+      // Find matching profile
+      const list = isActiveGlobal ? global : workspace;
+      const profile = list.find(p => p.id === activeId);
+      if (profile) return { adapter: cached, profile };
+    }
+
+    // Load connection profile
+    const list = isActiveGlobal ? global : workspace;
+    const profile = list.find(p => p.id === activeId);
+    if (!profile) return null;
+
+    const adapter = this.createAdapter(profile, workspaceRoot);
+    this.activeInstances.set(cacheKey, adapter);
+    return { adapter, profile };
+  }
+
+  public static async closeAll(): Promise<void> {
+    for (const [, instance] of this.activeInstances.entries()) {
+      await instance.disconnect().catch(console.error);
+    }
+    this.activeInstances.clear();
+  }
+}

package/src/lib/sql/DbAdapter.ts

@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export interface TableSchema {
+  name: string;
+  type: string; // 'table' or 'view'
+}
+
+export interface ColumnSchema {
+  name: string;
+  type: string;
+  nullable: boolean;
+  defaultValue?: string | null;
+  isPrimaryKey: boolean;
+  isForeignKey: boolean;
+  referencedTable?: string | null;
+  referencedColumn?: string | null;
+}
+
+export interface QueryResult {
+  rows: any[];
+  fields?: string[];
+  affectedRows?: number;
+}
+
+export abstract class DbAdapter {
+  protected config: any;
+
+  constructor(config: any) {
+    this.config = config;
+  }
+
+  abstract connect(): Promise<void>;
+  abstract query(sql: string, params?: any[]): Promise<QueryResult>;
+  abstract listTables(): Promise<TableSchema[]>;
+  abstract describeTable(tableName: string): Promise<ColumnSchema[]>;
+  abstract disconnect(): Promise<void>;
+
+  async getSchemaSummary(): Promise<string> {
+    try {
+      const tables = await this.listTables();
+      let summary = `### Database Schema Summary\n\n`;
+      if (tables.length === 0) {
+        return summary + "*No tables found in this database.*";
+      }
+
+      for (const t of tables) {
+        summary += `#### Table: \`${t.name}\` (${t.type})\n`;
+        const columns = await this.describeTable(t.name);
+        summary += `| Column | Type | Nullable | Key | References |\n`;
+        summary += `|---|---|---|---|---|\n`;
+        for (const col of columns) {
+          const keyType = col.isPrimaryKey ? "PK" : col.isForeignKey ? "FK" : "";
+          const ref = col.isForeignKey ? `\`${col.referencedTable}.${col.referencedColumn}\`` : "";
+          summary += `| \`${col.name}\` | \`${col.type}\` | ${col.nullable ? "Yes" : "No"} | ${keyType} | ${ref} |\n`;
+        }
+        summary += `\n`;
+      }
+      return summary;
+    } catch (err) {
+      return `Failed to reflect schema summary: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+}

package/src/lib/sql/McpServer.ts

@@ -0,0 +1,278 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import readline from "readline";
+import { ConnectionManager } from "./ConnectionManager";
+
+export class McpServer {
+  private workspaceRoot?: string;
+
+  constructor(workspaceRoot?: string) {
+    this.workspaceRoot = workspaceRoot;
+    // Redirect console.log to stderr so that it doesn't corrupt stdout JSON-RPC stream
+    console.log = (...args) => {
+      console.error("[LOG]", ...args);
+    };
+  }
+
+  public start(): void {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+
+    rl.on("line", async (line) => {
+      if (!line.trim()) return;
+      try {
+        const message = JSON.parse(line);
+        if (message.method) {
+          const response = await this.handleMessage(message);
+          if (response) {
+            process.stdout.write(JSON.stringify(response) + "\n");
+          }
+        }
+      } catch (err) {
+        this.sendError(null, -32700, "Parse error: " + (err instanceof Error ? err.message : String(err)));
+      }
+    });
+
+    console.error("[McpServer] SQL Model Context Protocol Server listening on stdio...");
+    if (this.workspaceRoot) {
+      console.error(`[McpServer] Workspace Root Context resolved to: ${this.workspaceRoot}`);
+    }
+  }
+
+  public async handleMessage(message: any): Promise<any> {
+    const { id, method, params } = message;
+
+    switch (method) {
+      case "initialize":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: {}
+            },
+            serverInfo: {
+              name: "neural-loom-sql-mcp",
+              version: "1.0.0"
+            }
+          }
+        };
+
+      case "notifications/initialized":
+        return null;
+
+      case "tools/list":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: [
+              {
+                name: "sql_list_connections",
+                description: "Lists all configured global and workspace database connection profiles, and identifies which one is active.",
+                inputSchema: { type: "object", properties: {} }
+              },
+              {
+                name: "sql_list_tables",
+                description: "Lists all tables and views in the currently active database.",
+                inputSchema: { type: "object", properties: {} }
+              },
+              {
+                name: "sql_describe_table",
+                description: "Provides column names, types, primary keys, foreign keys, and nullability information for a specific table.",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    table: { type: "string", description: "The name of the table to describe." }
+                  },
+                  required: ["table"]
+                }
+              },
+              {
+                name: "sql_get_schema_summary",
+                description: "Returns a complete Markdown representation of the database schema, detailing all tables, columns, constraints, and relationships.",
+                inputSchema: { type: "object", properties: {} }
+              },
+              {
+                name: "sql_query",
+                description: "Executes a SQL query on the active database connection. Select queries return matching rows; modifying queries return affected row count. If readOnly is set on the connection, modifying statements will fail.",
+                inputSchema: {
+                  type: "object",
+                  properties: {
+                    sql: { type: "string", description: "The SQL statement to execute." }
+                  },
+                  required: ["sql"]
+                }
+              }
+            ]
+          }
+        };
+
+      case "tools/call":
+        return await this.handleToolCall(id, params);
+
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`
+          }
+        };
+    }
+  }
+
+  private async handleRequest(req: any): Promise<void> {
+    const response = await this.handleMessage(req);
+    if (response) {
+      process.stdout.write(JSON.stringify(response) + "\n");
+    }
+  }
+
+  private async handleToolCall(id: any, params: any): Promise<void> {
+    const toolName = params.name;
+    const args = params.arguments || {};
+
+    try {
+      if (toolName === "sql_list_connections") {
+        const res = await ConnectionManager.getProfiles(this.workspaceRoot);
+        const activeProfile = res.isActiveGlobal 
+          ? res.global.find(p => p.id === res.activeId)
+          : res.workspace.find(p => p.id === res.activeId);
+        
+        const responseText = `Active Connection Profile: ${activeProfile ? `${activeProfile.name} (${activeProfile.type})` : "None"}\n\n` +
+          `Global Profiles:\n` + (res.global.length > 0 ? res.global.map(p => `- [${p.id}] ${p.name} (${p.type}) ${res.activeId === p.id && res.isActiveGlobal ? "(Active)" : ""}`).join("\n") : "None") + "\n\n" +
+          `Workspace Profiles:\n` + (res.workspace.length > 0 ? res.workspace.map(p => `- [${p.id}] ${p.name} (${p.type}) ${res.activeId === p.id && !res.isActiveGlobal ? "(Active)" : ""}`).join("\n") : "None");
+        
+        this.sendToolResult(id, responseText);
+        return;
+      }
+
+      const active = await ConnectionManager.getActiveAdapter(this.workspaceRoot);
+      if (!active) {
+        this.sendToolResult(
+          id,
+          "Error: No active database connection is selected. Please configure and activate a database connection in the NeuralLoom workspace dashboard UI.",
+          true
+        );
+        return;
+      }
+
+      const { adapter, profile } = active;
+
+      switch (toolName) {
+        case "sql_list_tables": {
+          const tables = await adapter.listTables();
+          const listText = tables.length > 0
+            ? tables.map(t => `- \`${t.name}\` (${t.type})`).join("\n")
+            : "*No tables found in the active database.*";
+          this.sendToolResult(id, `Active Database: ${profile.name} (${profile.type})\n\n### Tables:\n${listText}`);
+          break;
+        }
+
+        case "sql_describe_table": {
+          const table = args.table;
+          if (!table) {
+            this.sendToolResult(id, "Error: Missing required argument 'table'.", true);
+            return;
+          }
+          const columns = await adapter.describeTable(table);
+          let text = `### Table Structure: \`${table}\` (Active Connection: ${profile.name})\n\n`;
+          text += `| Column | Type | Nullable | Key | References |\n`;
+          text += `|---|---|---|---|---|\n`;
+          for (const col of columns) {
+            const key = col.isPrimaryKey ? "PK" : col.isForeignKey ? "FK" : "";
+            const ref = col.isForeignKey ? `\`${col.referencedTable}.${col.referencedColumn}\`` : "";
+            text += `| \`${col.name}\` | \`${col.type}\` | ${col.nullable ? "Yes" : "No"} | ${key} | ${ref} |\n`;
+          }
+          this.sendToolResult(id, text);
+          break;
+        }
+
+        case "sql_get_schema_summary": {
+          const summary = await adapter.getSchemaSummary();
+          this.sendToolResult(id, summary);
+          break;
+        }
+
+        case "sql_query": {
+          const sql = args.sql;
+          if (!sql || !sql.trim()) {
+            this.sendToolResult(id, "Error: Missing required argument 'sql'.", true);
+            return;
+          }
+          
+          const clean = sql.trim().toLowerCase();
+          const isMutation = clean.startsWith("insert") ||
+                             clean.startsWith("update") ||
+                             clean.startsWith("delete") ||
+                             clean.startsWith("drop") ||
+                             clean.startsWith("alter") ||
+                             clean.startsWith("create") ||
+                             clean.startsWith("truncate") ||
+                             clean.startsWith("replace");
+
+          if (profile.readOnly && isMutation) {
+            this.sendToolResult(id, "Error: Access Denied. This database connection is configured as Read-Only.", true);
+            return;
+          }
+
+          const res = await adapter.query(sql);
+          if (res.affectedRows !== undefined) {
+            this.sendToolResult(id, `Query completed successfully. Affected rows: ${res.affectedRows}`);
+          } else {
+            this.sendToolResult(id, JSON.stringify(res.rows, null, 2));
+          }
+          break;
+        }
+
+        default:
+          this.sendError(id, -32601, `Tool not implemented: ${toolName}`);
+      }
+    } catch (err: any) {
+      this.sendToolResult(id, `Exception executing tool: ${err.message || String(err)}`, true);
+    }
+  }
+
+  private sendResponse(id: any, result: any): void {
+    const response = {
+      jsonrpc: "2.0",
+      id,
+      result
+    };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+
+  private sendToolResult(id: any, text: string, isError = false): void {
+    const response = {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        content: [
+          {
+            type: "text",
+            text
+          }
+        ],
+        isError
+      }
+    };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+
+  private sendError(id: any, code: number, message: string): void {
+    const response = {
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code,
+        message
+      }
+    };
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+}