veryfront 0.0.49 → 0.0.50

package/dist/integrations/snowflake/connector.json

@@ -0,0 +1,151 @@
+{
+  "name": "snowflake",
+  "displayName": "Snowflake",
+  "icon": "snowflake.svg",
+  "description": "Query and manage your Snowflake data warehouse with SQL operations across databases, schemas, and tables",
+  "auth": {
+    "type": "api-key",
+    "requiredApis": [
+      {
+        "name": "Snowflake Account",
+        "enableUrl": "https://app.snowflake.com/"
+      }
+    ]
+  },
+  "envVars": [
+    {
+      "name": "SNOWFLAKE_ACCOUNT",
+      "description": "Your Snowflake account identifier (e.g., xy12345.us-east-1)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-account-identifier"
+    },
+    {
+      "name": "SNOWFLAKE_USERNAME",
+      "description": "Snowflake username for authentication",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-user-management"
+    },
+    {
+      "name": "SNOWFLAKE_PASSWORD",
+      "description": "Snowflake password for authentication",
+      "required": true,
+      "sensitive": true,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-user-management"
+    },
+    {
+      "name": "SNOWFLAKE_WAREHOUSE",
+      "description": "Default warehouse to use for queries (e.g., COMPUTE_WH)",
+      "required": true,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/warehouses"
+    },
+    {
+      "name": "SNOWFLAKE_DATABASE",
+      "description": "Default database to use for queries",
+      "required": false,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/databases"
+    },
+    {
+      "name": "SNOWFLAKE_SCHEMA",
+      "description": "Default schema to use for queries (defaults to PUBLIC)",
+      "required": false,
+      "sensitive": false,
+      "docsUrl": "https://docs.snowflake.com/en/user-guide/schemas"
+    }
+  ],
+  "tools": [
+    {
+      "id": "run-query",
+      "name": "Run Query",
+      "description": "Execute a SQL query against your Snowflake data warehouse",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-databases",
+      "name": "List Databases",
+      "description": "List all databases in your Snowflake account",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-schemas",
+      "name": "List Schemas",
+      "description": "List all schemas in a Snowflake database",
+      "requiresWrite": false
+    },
+    {
+      "id": "list-tables",
+      "name": "List Tables",
+      "description": "List all tables in a Snowflake database schema",
+      "requiresWrite": false
+    },
+    {
+      "id": "describe-table",
+      "name": "Describe Table",
+      "description": "Get detailed column information for a specific table",
+      "requiresWrite": false
+    }
+  ],
+  "prompts": [
+    {
+      "id": "query-data",
+      "title": "Query my data warehouse",
+      "prompt": "Help me query data from my Snowflake data warehouse. Show me specific records or analyze patterns.",
+      "category": "data",
+      "icon": "search"
+    },
+    {
+      "id": "analyze-tables",
+      "title": "Analyze table structure",
+      "prompt": "Show me the structure of tables in my Snowflake database and help me understand the schema.",
+      "category": "data",
+      "icon": "database"
+    },
+    {
+      "id": "data-insights",
+      "title": "Generate insights",
+      "prompt": "Analyze my Snowflake data and generate insights about trends, patterns, and anomalies.",
+      "category": "analytics",
+      "icon": "chart"
+    },
+    {
+      "id": "optimize-queries",
+      "title": "Optimize queries",
+      "prompt": "Help me optimize my SQL queries for better performance in Snowflake.",
+      "category": "analytics",
+      "icon": "lightning"
+    }
+  ],
+  "setupGuide": {
+    "steps": [
+      {
+        "title": "Locate Your Account Identifier",
+        "description": "Find your Snowflake account identifier in the Snowflake web interface URL (e.g., xy12345.us-east-1 from https://xy12345.us-east-1.snowflakecomputing.com)",
+        "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-account-identifier"
+      },
+      {
+        "title": "Create or Use Existing User",
+        "description": "Use an existing Snowflake user or create a new one with appropriate permissions. The user needs USAGE privileges on the warehouse and database, and SELECT privileges on tables.",
+        "docsUrl": "https://docs.snowflake.com/en/user-guide/admin-user-management"
+      },
+      {
+        "title": "Configure Warehouse",
+        "description": "Ensure you have a warehouse created and running. The default warehouse is typically named COMPUTE_WH.",
+        "docsUrl": "https://docs.snowflake.com/en/user-guide/warehouses"
+      },
+      {
+        "title": "Set Environment Variables",
+        "description": "Add the following environment variables to your .env file with your Snowflake credentials",
+        "code": "SNOWFLAKE_ACCOUNT=xy12345.us-east-1\nSNOWFLAKE_USERNAME=your_username\nSNOWFLAKE_PASSWORD=your_password\nSNOWFLAKE_WAREHOUSE=COMPUTE_WH\nSNOWFLAKE_DATABASE=your_database\nSNOWFLAKE_SCHEMA=PUBLIC"
+      },
+      {
+        "title": "Test Connection",
+        "description": "Test your connection by listing databases or running a simple query",
+        "code": "SELECT CURRENT_VERSION()"
+      }
+    ]
+  },
+  "suggestedWith": ["github", "slack", "notion"]
+}

package/dist/integrations/snowflake/files/_env.example

@@ -0,0 +1,16 @@
+# Snowflake Integration
+# Get your account details from https://app.snowflake.com/
+
+# Your Snowflake account identifier (e.g., xy12345.us-east-1)
+SNOWFLAKE_ACCOUNT=xy12345.us-east-1
+
+# Authentication credentials
+SNOWFLAKE_USERNAME=your_username
+SNOWFLAKE_PASSWORD=your_password
+
+# Default warehouse for compute resources
+SNOWFLAKE_WAREHOUSE=COMPUTE_WH
+
+# Optional: Default database and schema
+SNOWFLAKE_DATABASE=your_database
+SNOWFLAKE_SCHEMA=PUBLIC

package/dist/integrations/snowflake/files/ai/tools/describe-table.ts

@@ -0,0 +1,57 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { describeTable, getTableRowCount } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "describe-table",
+  description:
+    "Get detailed schema information about a specific table in Snowflake. Returns column names, data types, constraints, and table statistics.",
+  inputSchema: z.object({
+    database: z.string().describe(
+      "The name of the database containing the table",
+    ),
+    schema: z.string().default("PUBLIC").describe(
+      "The name of the schema containing the table. Defaults to PUBLIC.",
+    ),
+    table: z.string().describe(
+      "The name of the table to describe",
+    ),
+    includeRowCount: z.boolean().default(false).describe(
+      "Include the current row count for the table (may be slow for large tables)",
+    ),
+  }),
+  async execute({ database, schema, table, includeRowCount }) {
+    const description = await describeTable(database, schema, table);
+
+    let rowCount: number | null = null;
+    if (includeRowCount) {
+      try {
+        rowCount = await getTableRowCount(database, schema, table);
+      } catch (_error) {
+        // Silently fail if row count cannot be retrieved
+        rowCount = null;
+      }
+    }
+
+    return {
+      database,
+      schema,
+      table,
+      rowCount,
+      primaryKeys: description.primaryKeys,
+      columnCount: description.columns.length,
+      columns: description.columns.map((col) => ({
+        name: col.name,
+        type: col.type,
+        kind: col.kind,
+        nullable: col.null === "Y",
+        default: col.default || null,
+        primaryKey: col.primary_key === "Y",
+        uniqueKey: col.unique_key === "Y",
+        check: col.check || null,
+        expression: col.expression || null,
+        comment: col.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/list-databases.ts

@@ -0,0 +1,34 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listDatabases } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "list-databases",
+  description:
+    "List all databases in your Snowflake account. Returns database names, creation dates, owners, and comments.",
+  inputSchema: z.object({
+    includeDetails: z.boolean().default(true).describe(
+      "Include detailed information like creation date, owner, and comments",
+    ),
+  }),
+  async execute({ includeDetails }) {
+    const databases = await listDatabases();
+
+    if (!includeDetails) {
+      return {
+        count: databases.length,
+        databases: databases.map((db) => db.name),
+      };
+    }
+
+    return {
+      count: databases.length,
+      databases: databases.map((db) => ({
+        name: db.name,
+        createdOn: db.created_on,
+        owner: db.owner,
+        comment: db.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/list-schemas.ts

@@ -0,0 +1,40 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listSchemas } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "list-schemas",
+  description:
+    "List all schemas in a Snowflake database. Returns schema names, database names, creation dates, and owners.",
+  inputSchema: z.object({
+    database: z.string().describe(
+      "The name of the database to list schemas from",
+    ),
+    includeDetails: z.boolean().default(true).describe(
+      "Include detailed information like creation date, owner, and comments",
+    ),
+  }),
+  async execute({ database, includeDetails }) {
+    const schemas = await listSchemas(database);
+
+    if (!includeDetails) {
+      return {
+        database,
+        count: schemas.length,
+        schemas: schemas.map((s) => s.name),
+      };
+    }
+
+    return {
+      database,
+      count: schemas.length,
+      schemas: schemas.map((s) => ({
+        name: s.name,
+        databaseName: s.database_name,
+        createdOn: s.created_on,
+        owner: s.owner,
+        comment: s.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/list-tables.ts

@@ -0,0 +1,49 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listTables } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "list-tables",
+  description:
+    "List all tables in a Snowflake database schema. Returns table names, types, creation dates, row counts, and sizes.",
+  inputSchema: z.object({
+    database: z.string().describe(
+      "The name of the database containing the schema",
+    ),
+    schema: z.string().default("PUBLIC").describe(
+      "The name of the schema to list tables from. Defaults to PUBLIC.",
+    ),
+    includeDetails: z.boolean().default(true).describe(
+      "Include detailed information like creation date, row count, size, and owner",
+    ),
+  }),
+  async execute({ database, schema, includeDetails }) {
+    const tables = await listTables(database, schema);
+
+    if (!includeDetails) {
+      return {
+        database,
+        schema,
+        count: tables.length,
+        tables: tables.map((t) => t.name),
+      };
+    }
+
+    return {
+      database,
+      schema,
+      count: tables.length,
+      tables: tables.map((t) => ({
+        name: t.name,
+        databaseName: t.database_name,
+        schemaName: t.schema_name,
+        kind: t.kind,
+        createdOn: t.created_on,
+        rowCount: t.row_count || null,
+        bytes: t.bytes || null,
+        owner: t.owner,
+        comment: t.comment || null,
+      })),
+    };
+  },
+});

package/dist/integrations/snowflake/files/ai/tools/run-query.ts

@@ -0,0 +1,119 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { getQueryStatus, runQuery } from "../../lib/snowflake-client.ts";
+
+export default tool({
+  id: "run-query",
+  description:
+    "Execute a SQL query against your Snowflake data warehouse. Supports SELECT, INSERT, UPDATE, DELETE, and other SQL operations.",
+  inputSchema: z.object({
+    sql: z.string().describe(
+      "The SQL query to execute. Can be SELECT, INSERT, UPDATE, DELETE, or DDL statements.",
+    ),
+    database: z.string().optional().describe(
+      "The database to use for this query. If not specified, uses the default database.",
+    ),
+    schema: z.string().optional().describe(
+      "The schema to use for this query. If not specified, uses the default schema.",
+    ),
+    timeout: z.number().min(1).max(300).default(60).describe(
+      "Query timeout in seconds (1-300). Default is 60 seconds.",
+    ),
+    async: z.boolean().default(false).describe(
+      "Execute query asynchronously. If true, returns immediately with a statement handle to check status later.",
+    ),
+  }),
+  async execute({ sql, database, schema, timeout, async: asyncExec }) {
+    const result = await runQuery(sql, database, schema, {
+      timeout,
+      async: asyncExec,
+    });
+
+    // Handle async execution
+    if (asyncExec && result.statementHandle) {
+      return {
+        status: "submitted",
+        statementHandle: result.statementHandle,
+        message:
+          "Query submitted for async execution. Use the statement handle to check status.",
+      };
+    }
+
+    // Handle synchronous result
+    return {
+      status: "completed",
+      sql,
+      database: database || "default",
+      schema: schema || "PUBLIC",
+      columns: result.columns,
+      rowCount: result.rowCount,
+      rows: result.rows,
+      statementHandle: result.statementHandle,
+    };
+  },
+});
+
+/**
+ * Additional tool for checking query status (for async queries)
+ */
+export const checkQueryStatus = tool({
+  id: "check-query-status",
+  description:
+    "Check the status and retrieve results of an asynchronously executed query.",
+  inputSchema: z.object({
+    statementHandle: z.string().describe(
+      "The statement handle returned from an async query execution.",
+    ),
+  }),
+  async execute({ statementHandle }) {
+    const status = await getQueryStatus(statementHandle);
+
+    // Check if query is complete
+    if (status.code === "090001") {
+      // Query is still running
+      return {
+        status: "running",
+        message: status.message,
+        statementHandle,
+      };
+    }
+
+    if (status.code === "000000" || !status.code) {
+      // Query completed successfully
+      const columns = status.resultSetMetaData?.rowType.map((col) => ({
+        name: col.name,
+        type: col.type,
+        nullable: col.nullable,
+      })) || [];
+
+      const rows: Record<string, unknown>[] = [];
+      if (status.data && status.resultSetMetaData) {
+        const columnNames = status.resultSetMetaData.rowType.map((col) => col.name);
+        for (const row of status.data) {
+          const obj: Record<string, unknown> = {};
+          columnNames.forEach((name, index) => {
+            obj[name] = row[index];
+          });
+          rows.push(obj);
+        }
+      }
+
+      return {
+        status: "completed",
+        columns,
+        rowCount: status.resultSetMetaData?.numRows || 0,
+        rows,
+        stats: status.stats,
+        statementHandle,
+      };
+    }
+
+    // Query failed
+    return {
+      status: "failed",
+      code: status.code,
+      message: status.message,
+      statementHandle,
+    };
+  },
+});