agentic-astra-catalog 0.0.1

package/components/ToolList.tsx

@@ -0,0 +1,75 @@
+import { Tool } from '@/lib/astraClient';
+
+interface ToolListProps {
+  tools: Tool[];
+  selectedTool: Tool | null;
+  onSelectTool: (tool: Tool) => void;
+  onNewTool: () => void;
+}
+
+export default function ToolList({ tools, selectedTool, onSelectTool, onNewTool }: ToolListProps) {
+  return (
+    <div className="w-80 border-r border-gray-300 dark:border-gray-700 bg-gray-50 dark:bg-gray-900 h-screen overflow-y-auto">
+      <div className="p-4 border-b border-gray-300 dark:border-gray-700">
+        <div className="flex justify-between items-center mb-2">
+          <h2 className="text-xl font-semibold text-gray-800 dark:text-gray-200">Tools</h2>
+        </div>
+        <p className="text-sm text-gray-600 dark:text-gray-400 mb-3">{tools.length} tool{tools.length !== 1 ? 's' : ''}</p>
+        <button
+          onClick={onNewTool}
+          className="w-full px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 transition-colors text-sm font-medium"
+        >
+          + New Tool
+        </button>
+      </div>
+      <div className="p-2">
+        {tools.length === 0 ? (
+          <div className="p-4 text-center text-gray-500 dark:text-gray-400">
+            No tools found
+          </div>
+        ) : (
+          <div className="space-y-1">
+            {tools.map((tool) => (
+              <button
+                key={tool._id || tool.name}
+                onClick={() => onSelectTool(tool)}
+                className={`w-full text-left p-3 rounded-lg transition-colors ${
+                  selectedTool?._id === tool._id || selectedTool?.name === tool.name
+                    ? 'bg-blue-100 dark:bg-blue-900 text-blue-900 dark:text-blue-100'
+                    : 'bg-white dark:bg-gray-800 text-gray-800 dark:text-gray-200 hover:bg-gray-100 dark:hover:bg-gray-700'
+                } ${tool.enabled === false ? 'opacity-60' : ''}`}
+              >
+                <div className="flex items-center justify-between">
+                  <div className="font-medium">{tool.name}</div>
+                  {tool.enabled === false && (
+                    <span className="text-xs px-2 py-0.5 rounded bg-red-100 dark:bg-red-900 text-red-700 dark:text-red-300">
+                      Disabled
+                    </span>
+                  )}
+                </div>
+                {tool.description && (
+                  <div className="text-sm text-gray-600 dark:text-gray-400 mt-1 line-clamp-2">
+                    {tool.description}
+                  </div>
+                )}
+                {tool.tags && tool.tags.length > 0 && (
+                  <div className="flex flex-wrap gap-1 mt-2">
+                    {tool.tags.map((tag, idx) => (
+                      <span
+                        key={idx}
+                        className="text-xs px-2 py-0.5 rounded bg-gray-200 dark:bg-gray-700 text-gray-700 dark:text-gray-300"
+                      >
+                        {tag}
+                      </span>
+                    ))}
+                  </div>
+                )}
+              </button>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+

package/lib/astraClient.ts

@@ -0,0 +1,264 @@
+import { DataAPIClient } from '@datastax/astra-db-ts';
+
+export interface ToolParameter {
+  param: string;
+  description?: string;
+  attribute?: string;
+  type?: string;
+  required?: boolean | number;
+  operator?: string;
+  expr?: string;
+  enum?: string[];
+  embedding_model?: string;
+  info?: string;
+  value?: any;
+  paramMode?: 'tool_param' | 'static' | 'expression';
+}
+
+export interface Tool {
+  _id?: string;
+  tags?: string[];
+  type: string;
+  name: string;
+  description?: string;
+  limit?: number;
+  method?: string;
+  collection_name?: string;
+  table_name?: string;
+  db_name?: string;
+  projection?: Record<string, number | string>;
+  parameters?: ToolParameter[];
+  enabled?: boolean;
+}
+
+class AstraClient {
+  private client: DataAPIClient | null = null;
+  private db: any = null;
+  private collection: any = null;
+  private token: string | null = null;
+  private endpoint: string | null = null;
+  private dbName: string | null = null;
+  private collectionName: string = 'tool_catalog';
+
+  async connect(): Promise<void> {
+    // Access server-side environment variables
+    this.token = process.env.ASTRA_DB_APPLICATION_TOKEN || '';
+    this.endpoint = process.env.ASTRA_DB_API_ENDPOINT || '';
+    this.dbName = process.env.ASTRA_DB_DB_NAME || '';
+    this.collectionName = process.env.ASTRA_DB_CATALOG_COLLECTION || 'tool_catalog';
+
+    if (!this.token || !this.endpoint || !this.dbName) {
+      throw new Error('Missing required environment variables: ASTRA_DB_APPLICATION_TOKEN, ASTRA_DB_API_ENDPOINT, and ASTRA_DB_DB_NAME are required');
+    }
+
+    try {
+      // Initialize the DataAPIClient with the token
+      this.client = new DataAPIClient(this.token);
+      
+      // Get the database using the endpoint and token
+      // The endpoint format: https://<database-id>-<region>.apps.astra.datastax.com
+      this.db = this.client.db(this.endpoint, { token: this.token });
+      
+      // Get the collection
+      this.collection = this.db.collection(this.collectionName);
+    } catch (error) {
+      throw new Error(`Failed to connect to Astra DB: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async getTools(): Promise<Tool[]> {
+    if (!this.collection) {
+      await this.connect();
+    }
+
+    try {
+      // Use find() with filter, which returns a cursor
+      const cursor = this.collection.find({ type: 'tool' });
+      
+      // Convert cursor to array
+      const tools: Tool[] = [];
+      for await (const doc of cursor) {
+        tools.push(doc as Tool);
+      }
+      
+      return tools;
+    } catch (error) {
+      throw new Error(`Failed to fetch tools: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async updateTool(tool: Tool): Promise<void> {
+    if (!this.collection) {
+      await this.connect();
+    }
+
+    try {
+      if (tool._id) {
+        // Update existing document
+        tool.enabled = tool.enabled === false ? false : true;
+        const _id = tool._id;
+        delete tool._id;
+        await this.collection.updateOne(
+          { _id: _id },
+          { $set: tool }
+        );
+      } else {
+        // Insert new document
+        await this.collection.insertOne({ document: tool });
+      }
+    } catch (error) {
+      throw new Error(`Failed to update tool: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async getSampleDocuments(tool: Tool, limit: number = 5): Promise<any[]> {
+    if (!this.db) {
+      await this.connect();
+    }
+
+    try {
+      const objectType = tool.collection_name ? 'collection' : 'table';
+      const objectName = tool.collection_name || tool.table_name;
+      const dbName = tool.db_name || this.dbName;
+
+      if (!objectName || !dbName) {
+        throw new Error('Collection/table name and database name are required');
+      }
+
+      // Get the target database
+      const targetDb = this.client!.db(this.endpoint!, { token: this.token });
+      
+      let targetObject: any;
+      if (objectType === 'collection') {
+        targetObject = targetDb.collection(objectName);
+      } else {
+        targetObject = targetDb.table(objectName);
+      }
+
+      // Fetch sample documents
+      const cursor = targetObject.find({}).limit(limit);
+      const documents: any[] = [];
+      for await (const doc of cursor) {
+        documents.push(doc);
+      }
+
+      return documents;
+    } catch (error) {
+      throw new Error(`Failed to fetch sample documents: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async listKeyspaces(): Promise<string[]> {
+    if (!this.client) {
+      await this.connect();
+    }
+
+    try {
+      // Get list of databases (keyspaces)
+      const admin = this.client!.admin();
+      const databases = await admin.listDatabases();
+      return databases.map((db: any) => db.name || db.id).filter(Boolean);
+    } catch (error) {
+      throw new Error(`Failed to list keyspaces: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async listCollections(dbName?: string): Promise<string[]> {
+    if (!this.db) {
+      await this.connect();
+    }
+
+    try {
+      const targetDbName = dbName || this.dbName;
+      if (!targetDbName) {
+        throw new Error('Database name is required');
+      }
+
+      // Get the database
+      const targetDb = this.client!.db(this.endpoint!, { token: this.token });
+      
+      // List collections
+      const collections = await targetDb.listCollections();
+      return collections.map((col: any) => col.name || col);
+    } catch (error) {
+      throw new Error(`Failed to list collections: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async listTables(dbName?: string): Promise<string[]> {
+    if (!this.db) {
+      await this.connect();
+    }
+
+    try {
+      const targetDbName = dbName || this.dbName;
+      if (!targetDbName) {
+        throw new Error('Database name is required');
+      }
+
+      // Get the database
+      const targetDb = this.client!.db(this.endpoint!, { token: this.token });
+      
+      // List tables
+      const tables = await targetDb.listTables();
+      return tables.map((table: any) => table.name || table);
+    } catch (error) {
+      throw new Error(`Failed to list tables: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+// Utility function to extract all attributes from documents (including nested)
+export function extractAttributes(documents: any[]): string[] {
+  const attributes = new Set<string>();
+
+  function extractFromObject(obj: any, prefix: string = '') {
+    if (obj === null || obj === undefined) {
+      return;
+    }
+
+    if (Array.isArray(obj)) {
+      // For arrays, check the first element if it's an object
+      if (obj.length > 0 && typeof obj[0] === 'object' && obj[0] !== null) {
+        extractFromObject(obj[0], prefix);
+      }
+      return;
+    }
+
+    if (typeof obj === 'object') {
+      for (const [key, value] of Object.entries(obj)) {
+        // Transform keys starting with "$" to "_$"
+        const transformedKey = key.startsWith('$') ? `_${key}` : key;
+        const fullKey = prefix ? `${prefix}.${transformedKey}` : transformedKey;
+
+        attributes.add(fullKey);
+
+        // Recursively extract nested attributes
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+          extractFromObject(value, fullKey);
+        } else if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object') {
+          extractFromObject(value[0], fullKey);
+        }
+      }
+    }
+  }
+
+  // Extract attributes from all documents
+  for (const doc of documents) {
+    extractFromObject(doc);
+  }
+
+  return Array.from(attributes).sort();
+}
+
+// Singleton instance
+let astraClientInstance: AstraClient | null = null;
+
+export function getAstraClient(): AstraClient {
+  if (!astraClientInstance) {
+    astraClientInstance = new AstraClient();
+  }
+  return astraClientInstance;
+}
+
+

package/next.config.js

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+}
+
+module.exports = nextConfig
+

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "agentic-astra-catalog",
+  "version": "0.0.1",
+  "description": "Next.js frontend for managing Astra DB tool catalog",
+  "main": "bin/agentic-astra-catalog.js",
+  "bin": {
+    "agentic-astra-catalog": "./bin/agentic-astra-catalog.js"
+  },
+  "keywords": [
+    "astra",
+    "datastax",
+    "catalog",
+    "tools",
+    "nextjs",
+    "react"
+  ],
+  "author": "Samuel Matioli",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/astra-mcp-server.git",
+    "directory": "frontend"
+  },
+  "files": [
+    "bin",
+    "app",
+    "components",
+    "lib",
+    "next.config.js",
+    "tailwind.config.js",
+    "tsconfig.json",
+    "postcss.config.js",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "postinstall": "echo '✅ Agentic Astra Catalog installed! Run with: npx agentic-astra-catalog'"
+  },
+  "dependencies": {
+    "@datastax/astra-db-ts": "^2.1.2",
+    "next": "^14.0.4",
+    "openai": "^4.20.1",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.6",
+    "@types/react": "^18.2.43",
+    "@types/react-dom": "^18.2.17",
+    "autoprefixer": "^10.4.16",
+    "postcss": "^8.4.32",
+    "tailwindcss": "^3.4.0",
+    "typescript": "^5.3.3"
+  }
+}

package/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

package/tailwind.config.js

@@ -0,0 +1,12 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    './app/**/*.{js,ts,jsx,tsx,mdx}',
+    './components/**/*.{js,ts,jsx,tsx,mdx}',
+  ],
+  darkMode: 'class',
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}