supatool 0.3.4 → 0.3.6

package/README.md

@@ -2,6 +2,14 @@
 
 A CLI tool that automatically generates TypeScript CRUD code from Supabase type definitions.
 
+## Features
+- Extract and categorize all database objects (tables, views, RLS, functions, triggers) from Supabase
+- Generate TypeScript CRUD functions from Supabase types or model YAML
+- Output human-readable and AI-friendly schema/index files
+- Flexible environment/configuration and batch processing
+- Simple CLI with help and documentation
+
+> For all new features and version history, see [CHANGELOG.md](./CHANGELOG.md).
 
 ## Install
 
@@ -15,7 +23,7 @@ pnpm add -g supatool
 
 ## Usage
 
-### 1. Extract Database Schema (NEW in v0.3.0)
+### Extract Database Schema
 
 Extract and categorize all database objects from your Supabase project:
 
@@ -50,7 +58,7 @@ supabase/schemas/
 └── rpc/                  # Functions & triggers
 ```
 
-### 2. Generate CRUD Code
+### Generate CRUD Code
 
 Generate TypeScript CRUD functions from Supabase types:
 
@@ -67,7 +75,7 @@ supatool gen:crud model.yaml
 
 **Output:** `src/integrations/supabase/crud-autogen/`
 
-### 3. Environment Configuration
+### Environment Configuration
 
 For security and convenience, set your connection string in environment variables:
 
@@ -88,7 +96,7 @@ supatool extract --all -o supabase/schemas
 - `DATABASE_URL` (fallback)
 - `SUPATOOL_MAX_CONCURRENT` (max concurrent table processing, default: 20, max: 50)
 
-### 4. Additional Commands
+### Additional Commands
 
 ```bash
 # Show help for all commands
@@ -98,16 +106,12 @@ supatool help
 supatool crud -i path/to/types -o path/to/output
 ```
 
-## Note: Supabase Client Requirement
+## Database Comments
 
-The generated CRUD code assumes that a Supabase client is defined in ../client.ts (relative to the export folder).
-Example:
+Supatool automatically extracts and includes PostgreSQL comments in all generated files. Comments enhance documentation and AI understanding of your schema.
 
-```ts
-// src/integrations/supabase/client.ts
-import { createClient } from '@supabase/supabase-js'
-export const supabase = createClient('YOUR_SUPABASE_URL', 'YOUR_SUPABASE_ANON_KEY')
-```
+- Table, view, function, and type comments are included in generated SQL and documentation.
+- AI-friendly index files (llms.txt) and Markdown index (index.md) include comments for better context.
 
 ## VSCode/Cursor Integration
 
@@ -271,99 +275,56 @@ supatool extract --all --schema public,auth,extensions -o supabase/schemas
 supatool extract --all -c "postgresql://..." -o supabase/schemas
 ```
 
-## New Features (v0.3.0)
-
-- **🔍 Schema Extraction**: Extract and categorize all database objects (tables, views, RLS, functions, triggers)
-- **📋 Supabase Declarative Schema**: Fully compliant with [Supabase's declarative database schemas](https://supabase.com/docs/guides/local-development/declarative-database-schemas) workflow
-- **🤖 AI-Friendly Index**: Auto-generated index.md and llms.txt files for better AI understanding of schema structure  
-- **💬 Comment Support**: Automatically extracts and includes database comments in generated files
-- **📁 Organized Output**: Separate directories for different object types with flexible organization options
-- **🎯 Pattern Matching**: Extract specific tables/views using wildcard patterns
-- **👁️ View Support**: Enhanced CRUD generation with SELECT-only operations for database views
-- **⚛️ React Query Integration**: Generate modern React hooks for data fetching
-- **🔧 Flexible Workflows**: Support both database-first and model-first development approaches
-
-## Changelog
-
-### v0.3.4
-
-- **FIXED**: Corrected RLS policy to proper format
-- **FIXED**: Ensured semicolon (;) is properly appended to function definitions
-- **FIXED**: Removed trailing whitespace from RLS template files
-
-### v0.3.3
-
-- **ENHANCED**: Improved SQL comment placement (moved to end of each SQL statement)
-- **ENHANCED**: Unified comment format for tables, views, functions, and custom types
-- **FIXED**: Preserved view `security_invoker` settings
-
-### v0.3.2
-
-- **ENHANCED**: Adjust for extensions(vector, geometry etc.)
-- **FIXED**: USER-DEFINED column types are now rendered with full type definitions (e.g. `vector(1536)`, `geometry(Point,4326)`).
-- **ADDED**: `FOREIGN KEY` constraints are now included as `CONSTRAINT ... FOREIGN KEY ... REFERENCES ...` inside generated `CREATE TABLE` statements.
-
-### v0.3.0
-
-**NEW Features:**
-- **NEW**: `extract` command for database schema extraction
-- **NEW**: Full compliance with Supabase declarative database schemas workflow
-- **NEW**: AI-friendly index.md and llms.txt generation for better schema understanding
-- **NEW**: Database comment extraction and integration
-- **NEW**: Organized directory structure (tables/, views/, rls/, rpc/)
-- **NEW**: Pattern matching for selective extraction
-- **ENHANCED**: Support for all database object types (RLS, functions, triggers, cron jobs, custom types)
-- **ENHANCED**: Flexible output options with --no-separate compatibility
-
-**Enhanced Error Handling:**
-- Comprehensive try-catch blocks for all CRUD operations
-- Enhanced null/undefined checks with proper fallbacks
-- Detailed error messages with contextual information
-- Special handling for PGRST116 errors (record not found)
-- Parameter validation for required fields
-- Proper error logging and debugging support
-
-**Breaking Changes:**
-- **Function Parameter Format**: All CRUD functions now use destructuring assignment
-  - Before: `selectTableRowById(id: string)`
-  - After: `selectTableRowById({ id }: { id: string })`
-- **Type Safety**: Enhanced TypeScript type annotations for all functions
-
-### v0.2.0
-- Added `gen:` commands for code and schema generation
-- Enhanced `create` command  
-- Introduced model schema support (`schemas/supatool-data.schema.ts`)
+## Seed Command (v0.3.5+)
 
-## Database Comments
+Export selected table data from your remote Supabase DB as AI-friendly seed JSON files.
 
-Supatool automatically extracts and includes PostgreSQL comments in all generated files. Comments enhance documentation and AI understanding of your schema.
+### Usage
 
-### Adding Comments to Your Database
+```
+supatool seed --tables tables.yaml --connection <CONNECTION_STRING>
+```
 
-```sql
--- Table comments
-COMMENT ON TABLE users IS 'User account information and authentication data';
+- `tables.yaml` example:
+  ```yaml
+  tables:
+    - users
+    - public.orders
+  ```
+- Output: `supabase/seeds/<timestamp>_supatool/{table}_seed.json`
+- Each file contains a snapshot of the remote DB table at the time of export.
 
--- View comments
-COMMENT ON VIEW user_profiles IS 'Combined user data with profile information';
+### Example output (users_seed.json)
+```json
+{
+  "table": "public.users",
+  "fetched_at": "2024-07-05T11:16:00Z",
+  "fetched_by": "supatool v0.3.5",
+  "note": "This data is a snapshot of the remote DB at the above time. For AI coding reference. You can update it by running the update command again.",
+  "rows": [
+    { "id": 1, "name": "Taro Yamada", "email": "taro@example.com" },
+    { "id": 2, "name": "Hanako Suzuki", "email": "hanako@example.com" }
+  ]
+}
+```
 
--- Function comments
-COMMENT ON FUNCTION update_timestamp() IS 'Automatically updates the updated_at column';
+> **Warning:** Do not include sensitive or personal data in seed files. Handle all exported data with care.
 
--- Custom type comments
-COMMENT ON TYPE user_status IS 'Enumeration of possible user account statuses';
-```
+### llms.txt (AI seed data index)
 
-### Comment Integration
+After exporting, a file named `llms.txt` is automatically generated (and overwritten) in the `supabase/seeds/` directory. This file lists all seed JSON files in the latest timestamped folder, with table name, fetch time, and row count for AI reference.
+
+- Note: `llms.txt` is not generated inside each timestamped subfolder, only in `supabase/seeds/`.
+
+#### Example llms.txt
+```
+# AI seed data index (generated by supatool)
+# fetched_at: 2024-07-05T11:16:00Z
+# folder: 20240705_1116_supatool
+public.users: users_seed.json (2 rows) # User account table
+public.orders: orders_seed.json (5 rows)
+```
 
-Comments appear in:
-- **index.md**: Human-readable file listings with descriptions (tables/views only)
-- **llms.txt**: AI-friendly format (`type:name:path:comment`)
-- **Generated SQL**: As `COMMENT ON` statements for full schema recreation
+## More Information
 
-**Example output:**
-```markdown
-## Tables
-- [users](tables/users.sql) - User account information and authentication data
-- [posts](tables/posts.sql) - User-generated content and blog posts
-```
+For full version history and detailed changes, see [CHANGELOG.md](./CHANGELOG.md).

package/dist/bin/helptext.js

@@ -4,15 +4,13 @@ exports.modelSchemaHelp = exports.helpText = void 0;
 // See: [src/bin/helptext.ts](./src/bin/helptext.ts) from project root
 // Help text (command section from README, English only)
 exports.helpText = `
-Supatool CLI - Supabase database schema extraction and TypeScript CRUD generation
+Supatool CLI - Supabase schema extraction and TypeScript CRUD generation
 
 Usage:
   supatool <command> [options]
 
 Commands:
-  extract            Extract and categorize database objects from Supabase
-  gen:schema-crud    Generate CRUD code from supabase/schemas SQL files
-  crud               Generate CRUD code from Supabase type definitions
+  extract            Extract database objects from Supabase
   gen:types          Generate TypeScript types from model YAML
   gen:crud           Generate CRUD TypeScript code from model YAML
   gen:docs           Generate Markdown documentation from model YAML
@@ -20,83 +18,21 @@ Commands:
   gen:rls            Generate RLS/security SQL from model YAML
   gen:all            Generate all outputs from model YAML
   create             Generate a template model YAML
+  crud               Generate CRUD code from Supabase type definitions
+  sync               Sync local and remote schemas
+  seed               Export selected table data as AI-friendly seed JSON
   config:init        Generate configuration template
   help               Show help
 
-Extract Options:
+Common Options:
   -c, --connection <string>    Supabase connection string
-  -o, --output-dir <path>      Output directory (default: ./supabase/schemas)
-  -t, --tables <pattern>       Table pattern with wildcards (default: *)
-  --tables-only                Extract only table definitions
-  --views-only                 Extract only view definitions
-  --all                        Extract all DB objects (tables, views, RLS, functions, triggers, cron, types)
-  --no-separate                Output all objects in same directory
-  --schema <schemas>           Target schemas, comma-separated (default: public)
-
-Examples:
-  # Set connection in .env.local (recommended)
-  echo "SUPABASE_CONNECTION_STRING=postgresql://..." >> .env.local
-  
-  # Extract all database objects with AI-friendly index
-  supatool extract --all -o supabase/schemas
-  # Output:
-  #   supabase/schemas/index.md (Human-readable index with table/view comments)
-  #   supabase/schemas/llms.txt (AI-friendly structured data with comments)
-  #   supabase/schemas/tables/*.sql (Tables with comments)
-  #   supabase/schemas/views/*.sql (Views with comments)
-  #   supabase/schemas/rls/*.sql (RLS policies)
-  #   supabase/schemas/rpc/*.sql (Functions & triggers)
-  #   supabase/schemas/cron/*.sql (Cron jobs)
-  #   supabase/schemas/types/*.sql (Custom types)
-
-  # Extract only tables and views (default)
-  supatool extract -o supabase/schemas
-
-  # Extract to single directory (legacy mode)
-  supatool extract --no-separate -o supabase/schemas
-
-  # Extract specific pattern
-  supatool extract -t "user_*" -o ./user-tables
-
-  # Extract from specific schemas (default: public)
-  supatool extract --all --schema public,auth,extensions -o supabase/schemas
-
-  # Alternative: specify connection directly
-  supatool extract --all -c "postgresql://..." -o supabase/schemas
-
-  # Complete database-first workflow
-  echo "SUPABASE_CONNECTION_STRING=postgresql://..." >> .env.local
-  supatool extract --all -o supabase/schemas
-  supatool gen:schema-crud --include-views --react-query
-
-  # Model-first workflow
-  supatool create model.yaml
-  supatool gen:all model.yaml
-
-  # Legacy CRUD generation
-  supatool crud
+  -o, --output-dir <path>      Output directory
+  -t, --tables <pattern|path>  Table pattern or YAML path
+  --schema <schemas>           Target schemas (comma-separated)
+  --config <path>              Configuration file path
+  -f, --force                  Force overwrite
 
-Database Comments:
-  Supatool automatically extracts and includes database comments in generated files.
-  
-  To add comments to your database objects:
-  
-  # Table comments
-  COMMENT ON TABLE users IS 'User account information';eha,
-  
-  # View comments
-  COMMENT ON VIEW user_profiles IS 'Combined user data with profile information';
-  
-  # Function comments
-  COMMENT ON FUNCTION update_timestamp() IS 'Automatically updates the updated_at column';
-  
-  # Custom type comments
-  COMMENT ON TYPE user_status IS 'Enumeration of possible user account statuses';
-  
-  Comments will appear in:
-  - index.md: Human-readable list with descriptions (tables/views only)
-  - llms.txt: AI-friendly format (type:name:path:comment)
-  - Generated SQL files: As COMMENT statements
+For details, see the documentation.
 `;
 // Model Schema Usage
 exports.modelSchemaHelp = `

package/dist/bin/supatool.js

@@ -18,6 +18,7 @@ const sqlGenerator_1 = require("../generator/sqlGenerator");
 const rlsGenerator_1 = require("../generator/rlsGenerator");
 const sync_1 = require("../sync");
 const definitionExtractor_1 = require("../sync/definitionExtractor");
+const seedGenerator_1 = require("../sync/seedGenerator");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
@@ -193,6 +194,73 @@ program
     .action(() => {
     console.log(helptext_1.helpText);
 });
+// sync コマンド
+program
+    .command('sync')
+    .description('ローカルスキーマとリモートスキーマを同期')
+    .option('-c, --connection <string>', 'Supabase connection string')
+    .option('-s, --schema-dir <path>', 'ローカルスキーマディレクトリ', './supabase/schemas')
+    .option('-t, --tables <pattern>', 'テーブルパターン（ワイルドカード対応）', '*')
+    .option('-f, --force', '強制上書き（確認なし）')
+    .option('--config <path>', '設定ファイルパス')
+    .action(async (options) => {
+    const config = (0, sync_1.resolveConfig)({
+        connectionString: options.connection
+    }, options.config);
+    if (!config.connectionString) {
+        console.error('Connection string is required. Set it using one of:');
+        console.error('1. --connection option');
+        console.error('2. SUPABASE_CONNECTION_STRING environment variable');
+        console.error('3. DATABASE_URL environment variable');
+        console.error('4. supatool.config.json configuration file');
+        process.exit(1);
+    }
+    try {
+        await (0, sync_1.syncAllTables)({
+            connectionString: config.connectionString,
+            schemaDir: options.schemaDir,
+            tablePattern: options.tables,
+            force: options.force
+        });
+    }
+    catch (error) {
+        console.error('⚠️ Sync error:', error);
+        process.exit(1);
+    }
+});
+// seed コマンド
+program
+    .command('seed')
+    .description('指定テーブルのデータをリモートDBから取得し、AI用シードJSONを生成')
+    .option('-c, --connection <string>', 'Supabase接続文字列')
+    .option('-t, --tables <path>', '取得テーブル一覧YAML', 'tables.yaml')
+    .option('-o, --out <dir>', '出力ディレクトリ', 'supabase/seeds')
+    .option('--config <path>', '設定ファイルパス')
+    .action(async (options) => {
+    // 接続情報の解決
+    const config = (0, sync_1.resolveConfig)({
+        connectionString: options.connection
+    }, options.config);
+    if (!config.connectionString) {
+        console.error('Connection string is required. Set it using one of:');
+        console.error('1. --connection option');
+        console.error('2. SUPABASE_CONNECTION_STRING environment variable');
+        console.error('3. DATABASE_URL environment variable');
+        console.error('4. supatool.config.json configuration file');
+        process.exit(1);
+    }
+    try {
+        await (0, seedGenerator_1.generateSeedsFromRemote)({
+            connectionString: config.connectionString,
+            tablesYamlPath: options.tables,
+            outputDir: options.out
+        });
+    }
+    catch (error) {
+        console.error('⚠️ Seed取得エラー:', error);
+        process.exit(1);
+    }
+});
 // If no subcommand is specified, show helpText only (do not call main)
 if (!process.argv.slice(2).length) {
     console.log(helptext_1.helpText);

package/dist/generator/crudGenerator.js

@@ -85,6 +85,8 @@ function generateCrudFromModel(model, outDir) {
         // フィルターで検索関数
         code += `/** フィルターで複数件取得 */\n`;
         code += `export async function select${capitalizedName}RowsWithFilters({ filters }: { filters: Filters }): Promise<${tableName}[]> {\n`;
+        code += `  // filtersのガード\n`;
+        code += `  if (!filters || typeof filters !== 'object') return [];\n`;
         code += `  try {\n`;
         code += `    let query = supabase.from('${tableName}').select('*');\n`;
         code += `    \n`;

package/dist/index.js

@@ -82,36 +82,50 @@ function main() {
             const typeName = typeAliasDecl.name.text;
             const typeNode = typeAliasDecl.type;
             if (typeNode.kind === typescript_1.SyntaxKind.TypeLiteral && typeName === 'Database') {
-                const schemaName = getSchemaName(typeNode);
-                const schemaType = typeNode.members.find((member) => member.name && member.name.text === schemaName);
-                if (schemaType && schemaType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
-                    const tablesAndViewsType = schemaType.type.members.filter((member) => member.name && (member.name.text === 'Tables' || member.name.text === 'Views'));
-                    return tablesAndViewsType.flatMap((tablesOrViewsType) => {
-                        if (tablesOrViewsType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
-                            return tablesOrViewsType.type.members.map((tableOrViewMember) => {
-                                const tableName = tableOrViewMember.name.text;
-                                const isView = tablesOrViewsType.name.text === 'Views';
-                                const rowType = tableOrViewMember.type.members.find((member) => member.name && member.name.text === 'Row');
-                                if (rowType && rowType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
-                                    const fields = rowType.type.members.map((member) => {
-                                        if (member.name && member.name.kind === typescript_1.SyntaxKind.Identifier) {
-                                            const name = member.name.getText(sourceFile);
-                                            const type = member.type ? member.type.getText(sourceFile) : 'unknown';
-                                            return { name, type };
-                                        }
-                                        return { name: 'unknown', type: 'unknown' };
-                                    });
-                                    return { typeName: tableName, fields, isView };
-                                }
-                                return null;
-                            }).filter((type) => type !== null);
-                        }
-                        return [];
-                    });
-                }
+                console.log('Found Database type, processing schemas...');
+                // Database型内の全てのスキーマを処理
+                return typeNode.members.flatMap((schemaMember) => {
+                    if (schemaMember.name && schemaMember.type && schemaMember.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
+                        const schemaName = schemaMember.name.text;
+                        console.log(`Processing schema: ${schemaName}`);
+                        const schemaType = schemaMember.type;
+                        // スキーマ内のTablesとViewsを処理
+                        const tablesAndViewsType = schemaType.members.filter((member) => member.name && (member.name.text === 'Tables' || member.name.text === 'Views'));
+                        return tablesAndViewsType.flatMap((tablesOrViewsType) => {
+                            if (tablesOrViewsType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
+                                const tableCount = tablesOrViewsType.type.members.length;
+                                console.log(`Found ${tableCount} ${tablesOrViewsType.name.text} in schema ${schemaName}`);
+                                return tablesOrViewsType.type.members.map((tableOrViewMember) => {
+                                    const tableName = tableOrViewMember.name.text;
+                                    const isView = tablesOrViewsType.name.text === 'Views';
+                                    console.log(`Processing ${isView ? 'view' : 'table'}: ${tableName}`);
+                                    const rowType = tableOrViewMember.type.members.find((member) => member.name && member.name.text === 'Row');
+                                    if (rowType && rowType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
+                                        const fields = rowType.type.members.map((member) => {
+                                            if (member.name && member.name.kind === typescript_1.SyntaxKind.Identifier) {
+                                                const name = member.name.getText(sourceFile);
+                                                const type = member.type ? member.type.getText(sourceFile) : 'unknown';
+                                                return { name, type };
+                                            }
+                                            return { name: 'unknown', type: 'unknown' };
+                                        });
+                                        return { typeName: tableName, fields, isView, schema: schemaName };
+                                    }
+                                    return null;
+                                }).filter((type) => type !== null);
+                            }
+                            return [];
+                        });
+                    }
+                    return [];
+                });
             }
             return [];
         });
+        console.log(`Total types found: ${types.length}`);
+        types.forEach(type => {
+            console.log(`- ${type.schema}.${type.typeName} (${type.isView ? 'view' : 'table'}) with ${type.fields.length} fields`);
+        });
         // Show start of generation process
         console.log(`Import path: ${importPath}`);
         console.log(`Export path: ${exportPath}`);
@@ -129,23 +143,25 @@ function main() {
             return true;
         })
             .forEach(type => {
+            // スキーマごとにフォルダ分け
+            const schemaFolder = path_1.default.join(crudFolderPath, type.schema);
+            if (!(0, fs_1.existsSync)(schemaFolder)) {
+                (0, fs_1.mkdirSync)(schemaFolder, { recursive: true });
+            }
             const fileName = toLowerCamelCase(type.typeName);
-            const crudCode = crudTemplate(type.typeName, type.fields, type.isView);
-            const filePath = crudFolderPath + `${fileName}.ts`;
+            // スキーマフォルダ分けがある場合のインポートパス調整
+            const hasSchemaFolders = types.some(t => t.schema !== type.schema);
+            const crudCode = crudTemplate(type.typeName, type.fields, type.isView, type.schema, hasSchemaFolders);
+            const filePath = path_1.default.join(schemaFolder, `${fileName}.ts`);
             // Show in console
             if (type.isView) {
-                console.log(`Generating select operations only for view: ${fileName}`);
+                console.log(`Generating select operations only for view: ${type.schema}/${fileName}`);
             }
             else {
-                console.log(`Generating full CRUD operations for table: ${fileName}`);
-            }
-            // Create directory if it does not exist
-            const dirPath = filePath.substring(0, filePath.lastIndexOf('/'));
-            if (!(0, fs_1.existsSync)(dirPath)) {
-                (0, fs_1.mkdirSync)(dirPath, { recursive: true });
+                console.log(`Generating full CRUD operations for table: ${type.schema}/${fileName}`);
             }
             (0, fs_1.writeFileSync)(filePath, crudCode);
-            console.log(`Generated ${fileName}.ts`);
+            console.log(`Generated ${type.schema}/${fileName}.ts`);
         });
         console.log("CRUD operations have been generated.");
     }
@@ -158,8 +174,8 @@ const toLowerCamelCase = (str) => {
 const toUpperCamelCase = (str) => {
     return str.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
 };
-// CRUD template
-const crudTemplate = (typeName, fields, isView) => {
+// CRUDテンプレート本体 - エレガントな文字列生成
+const crudTemplate = (typeName, fields, isView, schema, hasSchemaFolders) => {
     const upperCamelTypeName = toUpperCamelCase(typeName);
     const getByIdFunctionName = 'select' + upperCamelTypeName + 'RowById';
     const getByFiltersFunctionName = 'select' + upperCamelTypeName + 'RowsWithFilters';
@@ -168,233 +184,198 @@ const crudTemplate = (typeName, fields, isView) => {
     const updateFunctionName = 'update' + upperCamelTypeName + 'Row';
     const deleteFunctionName = 'delete' + upperCamelTypeName + 'Row';
     const idType = fields.find((field) => field.name === 'id')?.type || 'string';
-    const hasIdColumn = idType !== undefined; // Check if 'id' column exists
-    const exportHeaders = `// Supabase CRUD operations for ${typeName}
-// This file is automatically generated. Do not edit it directly.
-import { supabase } from "../client";
-import { Tables, TablesInsert, TablesUpdate } from "@shared/types";
-
-type ${typeName} = Tables<'${typeName}'>;
-type FilterTypesValue = string | number | boolean | null | Record<string, any>;
-type Filters = Record<string, FilterTypesValue | FilterTypesValue[]>;
-`;
-    const exportSelectById = `
-// Read single row using id
-export async function ${getByIdFunctionName}({ id }: { id: ${idType} }): Promise<${typeName} | null> {
-    if (!id) {
-        throw new Error('ID is required');
-    }
-    try {
-        const result = await supabase
-            .from('${typeName.toLowerCase()}')
-            .select('*')
-            .eq('id', id)
-            .single();
-        
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                return null;
-            }
-            throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);
-        }
-        
-        return result.data as ${typeName};
-    } catch (error) {
-        console.error('Error in ${getByIdFunctionName}:', error);
-        throw error;
-    }
-}
-`;
-    const exportSelectQueries = `
-  // Function to apply filters to a query
-function applyFilters(query: any, filters: Filters): any {
-    for (const [key, value] of Object.entries(filters)) {
-        if (Array.isArray(value)) {
-            query = query.in(key, value); // Use 'in' for array values
-        } else if (typeof value === 'object' && value !== null) {
-            for (const [operator, val] of Object.entries(value)) {
-                switch (operator) {
-                    case 'eq':
-                        query = query.eq(key, val);
-                        break;
-                    case 'neq':
-                        query = query.neq(key, val);
-                        break;
-                    case 'like':
-                        query = query.like(key, val);
-                        break;
-                    case 'ilike':
-                        query = query.ilike(key, val);
-                        break;
-                    case 'lt':
-                        query = query.lt(key, val);
-                        break;
-                    case 'lte':
-                        query = query.lte(key, val);
-                        break;
-                    case 'gte':
-                        query = query.gte(key, val);
-                        break;
-                    case 'gt':
-                        query = query.gt(key, val);
-                        break;
-                    case 'contains':
-                        query = query.contains(key, val);
-                        break;
-                    case 'contains_any':
-                        query = query.contains_any(key, val);
-                        break;
-                    case 'contains_all':
-                        query = query.contains_all(key, val);
-                        break;
-                    // Add more operators as needed
-                    default:
-                        throw new Error('Unsupported operator: ' + operator);
-                }
-            }
-        } else {
-            query = query.eq(key, value); // Default to 'eq' for simple values
-        }
-    }
-    return query;
-}
-
-// Read multiple rows with dynamic filters
-export async function ${getByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName}[]> {
-    try {
-        let query = supabase.from('${typeName.toLowerCase()}').select('*');
-        query = applyFilters(query, filters);
-
-        const result = await query;
-        
-        if (result.error) {
-            throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);
-        }
-        
-        return (result.data as unknown as ${typeName}[]) || [];
-    } catch (error) {
-        console.error('Error in ${getByFiltersFunctionName}:', error);
-        throw error;
-    }
-}
-
-// Read a single row with dynamic filters
-export async function ${getSingleByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName} | null> {
-    try {
-        let query = supabase.from('${typeName.toLowerCase()}').select('*');
-        query = applyFilters(query, filters).single();
-
-        const result = await query;
-        
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                return null;
-            }
-            throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);
-        }
-        
-        return result.data as unknown as ${typeName};
-    } catch (error) {
-        console.error('Error in ${getSingleByFiltersFunctionName}:', error);
-        throw error;
-    }
-}
-`;
-    const exportInsertOperation = isView ? '' :
-        `
-// Create Function
-export async function ${createFunctionName}({ data }: { data: TablesInsert<'${typeName}'> }): Promise<${typeName}> {
-    if (!data) {
-        throw new Error('Data is required for creation');
-    }
-    try {
-        const result = await supabase
-            .from('${typeName}')
-            .insert([data])
-            .select()
-            .single();
-
-        if (result.error) {
-            throw new Error(\`Failed to create ${typeName}: \${result.error.message}\`);
-        }
-        
-        if (!result.data) {
-            throw new Error('No data returned after creation');
-        }
-        
-        return result.data as ${typeName};
-    } catch (error) {
-        console.error('Error in ${createFunctionName}:', error);
-        throw error;
-    }
-}
-`;
-    const exportUpdateOperation = isView ? '' :
-        `
-// Update Function
-export async function ${updateFunctionName}({ id, data }: { id: ${idType}; data: TablesUpdate<'${typeName}'> }): Promise<${typeName}> {
-    if (!id) {
-        throw new Error('ID is required for update');
-    }
-    if (!data || Object.keys(data).length === 0) {
-        throw new Error('Update data is required');
-    }
-    try {
-        const result = await supabase
-            .from('${typeName.toLowerCase()}')
-            .update(data)
-            .eq('id', id)
-            .select()
-            .single();
-            
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                throw new Error(\`${typeName} with ID \${id} not found\`);
-            }
-            throw new Error(\`Failed to update ${typeName}: \${result.error.message}\`);
-        }
-        
-        if (!result.data) {
-            throw new Error(\`${typeName} with ID \${id} not found\`);
-        }
-        
-        return result.data as ${typeName};
-    } catch (error) {
-        console.error('Error in ${updateFunctionName}:', error);
-        throw error;
-    }
-}
-`;
-    const exportDeleteOperation = isView ? '' :
-        `
-// Delete Function
-export async function ${deleteFunctionName}({ id }: { id: ${idType} }): Promise<boolean> {
-    if (!id) {
-        throw new Error('ID is required for deletion');
-    }
-    try {
-        const result = await supabase
-            .from('${typeName.toLowerCase()}')
-            .delete()
-            .eq('id', id);
-            
-        if (result.error) {
-            throw new Error(\`Failed to delete ${typeName}: \${result.error.message}\`);
-        }
-        
-        return true;
-    } catch (error) {
-        console.error('Error in ${deleteFunctionName}:', error);
-        throw error;
-    }
-}
-`;
-    // Export all functions
-    const exportAll = `
-// All functions are exported individually above
-`;
-    // Return all the code
-    return exportHeaders + exportSelectQueries + (hasIdColumn ? exportSelectById : '') + exportInsertOperation + exportUpdateOperation + exportDeleteOperation + exportAll;
+    // インポートパスを動的に調整
+    const importPath = hasSchemaFolders ? '../../client' : '../client';
+    // ヘッダー部分
+    const header = [
+        `// Supabase CRUD operations for ${typeName} (${schema} schema)`,
+        '// 自動生成ファイル',
+        `import { supabase } from "${importPath}";`,
+        'import { Tables, TablesInsert, TablesUpdate } from "@shared/types";',
+        '',
+        `type ${typeName} = Tables<'${typeName}'>;`,
+        'type FilterTypesValue = string | number | boolean | null | Record<string, any>;',
+        'type Filters = Record<string, FilterTypesValue | FilterTypesValue[]>;',
+        ''
+    ].join('\n');
+    // フィルター適用関数
+    const filterFunction = [
+        '/**',
+        ' * フィルター適用関数',
+        ' */',
+        'function applyFilters(query: any, filters: Filters): any {',
+        '  for (const [key, value] of Object.entries(filters)) {',
+        '    if (Array.isArray(value)) {',
+        '      query = query.in(key, value);',
+        '    } else if (typeof value === "object" && value !== null) {',
+        '      for (const [operator, val] of Object.entries(value)) {',
+        '        switch (operator) {',
+        '          case "eq": query = query.eq(key, val); break;',
+        '          case "neq": query = query.neq(key, val); break;',
+        '          case "like": query = query.like(key, val); break;',
+        '          case "ilike": query = query.ilike(key, val); break;',
+        '          case "lt": query = query.lt(key, val); break;',
+        '          case "lte": query = query.lte(key, val); break;',
+        '          case "gte": query = query.gte(key, val); break;',
+        '          case "gt": query = query.gt(key, val); break;',
+        '          case "contains": query = query.contains(key, val); break;',
+        '          case "contains_any": query = query.contains_any(key, val); break;',
+        '          case "contains_all": query = query.contains_all(key, val); break;',
+        '          default: throw new Error("Unsupported operator: " + operator);',
+        '        }',
+        '      }',
+        '    } else {',
+        '      query = query.eq(key, value);',
+        '    }',
+        '  }',
+        '  return query;',
+        '}',
+        ''
+    ].join('\n');
+    // IDで1件取得
+    const selectById = [
+        '/**',
+        ' * IDで1件取得',
+        ' */',
+        `export async function ${getByIdFunctionName}({ id }: { id: ${idType} }): Promise<${typeName} | null> {`,
+        '  if (!id) throw new Error("ID is required");',
+        '  try {',
+        '    const result = await supabase',
+        `      .schema("${schema}")`,
+        `      .from("${typeName.toLowerCase()}")`,
+        '      .select("*")',
+        '      .eq("id", id)',
+        '      .single();',
+        '    if (result.error) {',
+        '      if (result.error.code === "PGRST116") return null;',
+        `      throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);`,
+        '    }',
+        `    return result.data as ${typeName};`,
+        '  } catch (error) {',
+        `    console.error("Error in ${getByIdFunctionName}:", error);`,
+        '    throw error;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // フィルターで複数取得
+    const selectMultiple = [
+        '/**',
+        ' * フィルターで複数取得',
+        ' */',
+        `export async function ${getByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName}[]> {`,
+        '  if (!filters || typeof filters !== "object") return [];',
+        '  try {',
+        `    let query = supabase.schema("${schema}").from("${typeName.toLowerCase()}").select("*");`,
+        '    query = applyFilters(query, filters);',
+        '    const result = await query;',
+        `    if (result.error) throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);`,
+        `    return (result.data as unknown as ${typeName}[]) || [];`,
+        '  } catch (error) {',
+        `    console.error("Error in ${getByFiltersFunctionName}:", error);`,
+        '    throw error;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // フィルターで1件取得
+    const selectSingle = [
+        '/**',
+        ' * フィルターで1件取得',
+        ' */',
+        `export async function ${getSingleByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName} | null> {`,
+        '  if (!filters || typeof filters !== "object") return null;',
+        '  try {',
+        `    let query = supabase.schema("${schema}").from("${typeName.toLowerCase()}").select("*");`,
+        '    query = applyFilters(query, filters).single();',
+        '    const result = await query;',
+        '    if (result.error) {',
+        '      if (result.error.code === "PGRST116") return null;',
+        `      throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);`,
+        '    }',
+        `    return result.data as unknown as ${typeName};`,
+        '  } catch (error) {',
+        `    console.error("Error in ${getSingleByFiltersFunctionName}:", error);`,
+        '    throw error;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 追加（ビューでない場合のみ）
+    const insertOperation = isView ? '' : [
+        '/**',
+        ' * 追加',
+        ' */',
+        `export async function ${createFunctionName}({ data }: { data: TablesInsert<"${typeName}"> }): Promise<${typeName}> {`,
+        '  if (!data) throw new Error("Data is required for creation");',
+        '  try {',
+        '    const result = await supabase',
+        `      .schema("${schema}")`,
+        `      .from("${typeName.toLowerCase()}")`,
+        '      .insert([data])',
+        '      .select()',
+        '      .single();',
+        `    if (result.error) throw new Error(\`Failed to create ${typeName}: \${result.error.message}\`);`,
+        '    if (!result.data) throw new Error("No data returned after creation");',
+        `    return result.data as ${typeName};`,
+        '  } catch (error) {',
+        `    console.error("Error in ${createFunctionName}:", error);`,
+        '    throw error;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 更新（ビューでない場合のみ）
+    const updateOperation = isView ? '' : [
+        '/**',
+        ' * 更新',
+        ' */',
+        `export async function ${updateFunctionName}({ id, data }: { id: ${idType}; data: TablesUpdate<"${typeName}"> }): Promise<${typeName}> {`,
+        '  if (!id) throw new Error("ID is required for update");',
+        '  if (!data || Object.keys(data).length === 0) throw new Error("Update data is required");',
+        '  try {',
+        '    const result = await supabase',
+        `      .schema("${schema}")`,
+        `      .from("${typeName.toLowerCase()}")`,
+        '      .update(data)',
+        '      .eq("id", id)',
+        '      .select()',
+        '      .single();',
+        '    if (result.error) {',
+        `      if (result.error.code === "PGRST116") throw new Error(\`${typeName} with ID \${id} not found\`);`,
+        `      throw new Error(\`Failed to update ${typeName}: \${result.error.message}\`);`,
+        '    }',
+        `    if (!result.data) throw new Error(\`${typeName} with ID \${id} not found\`);`,
+        `    return result.data as ${typeName};`,
+        '  } catch (error) {',
+        `    console.error("Error in ${updateFunctionName}:", error);`,
+        '    throw error;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 削除（ビューでない場合のみ）
+    const deleteOperation = isView ? '' : [
+        '/**',
+        ' * 削除',
+        ' */',
+        `export async function ${deleteFunctionName}({ id }: { id: ${idType} }): Promise<boolean> {`,
+        '  if (!id) throw new Error("ID is required for deletion");',
+        '  try {',
+        '    const result = await supabase',
+        `      .schema("${schema}")`,
+        `      .from("${typeName.toLowerCase()}")`,
+        '      .delete()',
+        '      .eq("id", id);',
+        `    if (result.error) throw new Error(\`Failed to delete ${typeName}: \${result.error.message}\`);`,
+        '    return true;',
+        '  } catch (error) {',
+        `    console.error("Error in ${deleteFunctionName}:", error);`,
+        '    throw error;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 全体を結合
+    return header + filterFunction + selectById + selectMultiple + selectSingle + insertOperation + updateOperation + deleteOperation;
 };
-// console.log(crudFolderPath);
-// console.log(types);

package/dist/sync/definitionExtractor.js

@@ -1068,6 +1068,87 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
  */
 async function extractDefinitions(options) {
     const { connectionString, outputDir, separateDirectories = true, tablesOnly = false, viewsOnly = false, all = false, tablePattern = '*', force = false, schemas = ['public'] } = options;
+    // Node.jsのSSL証明書検証を無効化
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+    // 接続文字列の検証
+    if (!connectionString) {
+        throw new Error('接続文字列が設定されていません。以下のいずれかで設定してください:\n' +
+            '1. --connection オプション\n' +
+            '2. SUPABASE_CONNECTION_STRING 環境変数\n' +
+            '3. DATABASE_URL 環境変数\n' +
+            '4. supatool.config.json 設定ファイル');
+    }
+    // 接続文字列の形式検証
+    if (!connectionString.startsWith('postgresql://') && !connectionString.startsWith('postgres://')) {
+        throw new Error(`不正な接続文字列形式です: ${connectionString}\n` +
+            '正しい形式: postgresql://username:password@host:port/database');
+    }
+    // パスワード部分をURLエンコード
+    let encodedConnectionString = connectionString;
+    console.log('🔍 元の接続文字列:', connectionString);
+    try {
+        // パスワードに@が含まれる場合の特別処理
+        if (connectionString.includes('@') && connectionString.split('@').length > 2) {
+            console.log('⚠️ パスワードに@が含まれているため特別処理を実行');
+            // 最後の@を区切り文字として使用
+            const parts = connectionString.split('@');
+            const lastPart = parts.pop(); // 最後の部分（host:port/database）
+            const firstParts = parts.join('@'); // 最初の部分（postgresql://user:password）
+            console.log('   分割結果:');
+            console.log('   前半部分:', firstParts);
+            console.log('   後半部分:', lastPart);
+            // パスワード部分をエンコード
+            const colonIndex = firstParts.lastIndexOf(':');
+            if (colonIndex > 0) {
+                const protocolAndUser = firstParts.substring(0, colonIndex);
+                const password = firstParts.substring(colonIndex + 1);
+                const encodedPassword = encodeURIComponent(password);
+                encodedConnectionString = `${protocolAndUser}:${encodedPassword}@${lastPart}`;
+                console.log('   エンコード結果:');
+                console.log('   プロトコル+ユーザー:', protocolAndUser);
+                console.log('   元パスワード:', password);
+                console.log('   エンコードパスワード:', encodedPassword);
+                console.log('   最終接続文字列:', encodedConnectionString);
+            }
+        }
+        else {
+            console.log('✅ 通常のURL解析を実行');
+            // 通常のURL解析
+            const url = new URL(connectionString);
+            // ユーザー名にドットが含まれる場合の処理
+            if (url.username && url.username.includes('.')) {
+                console.log(`ユーザー名（ドット含む）: ${url.username}`);
+            }
+            if (url.password) {
+                // パスワード部分のみをエンコード
+                const encodedPassword = encodeURIComponent(url.password);
+                url.password = encodedPassword;
+                encodedConnectionString = url.toString();
+                console.log('   パスワードエンコード:', encodedPassword);
+            }
+        }
+        // Supabase接続用にSSL設定を追加
+        if (!encodedConnectionString.includes('sslmode=')) {
+            const separator = encodedConnectionString.includes('?') ? '&' : '?';
+            encodedConnectionString += `${separator}sslmode=require`;
+            console.log('   SSL設定を追加:', encodedConnectionString);
+        }
+        // デバッグ情報を表示（パスワードは隠す）
+        const debugUrl = new URL(encodedConnectionString);
+        const maskedPassword = debugUrl.password ? '*'.repeat(debugUrl.password.length) : '';
+        debugUrl.password = maskedPassword;
+        console.log('🔍 接続情報:');
+        console.log(`   ホスト: ${debugUrl.hostname}`);
+        console.log(`   ポート: ${debugUrl.port}`);
+        console.log(`   データベース: ${debugUrl.pathname.slice(1)}`);
+        console.log(`   ユーザー: ${debugUrl.username}`);
+        console.log(`   SSL: ${debugUrl.searchParams.get('sslmode') || 'require'}`);
+    }
+    catch (error) {
+        // URL解析に失敗した場合は元の文字列を使用
+        console.warn('接続文字列のURL解析に失敗しました。特殊文字が含まれている可能性があります。');
+        console.warn('エラー詳細:', error instanceof Error ? error.message : String(error));
+    }
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
     const readline = await Promise.resolve().then(() => __importStar(require('readline')));
     // 上書き確認
@@ -1091,8 +1172,18 @@ async function extractDefinitions(options) {
     // スピナーを動的インポート
     const { default: ora } = await Promise.resolve().then(() => __importStar(require('ora')));
     const spinner = ora('Connecting to database...').start();
-    const client = new pg_1.Client({ connectionString });
+    const client = new pg_1.Client({
+        connectionString: encodedConnectionString,
+        ssl: {
+            rejectUnauthorized: false,
+            ca: undefined
+        }
+    });
     try {
+        // 接続前のデバッグ情報
+        console.log('🔧 接続設定:');
+        console.log(`   SSL: rejectUnauthorized=false`);
+        console.log(`   接続文字列長: ${encodedConnectionString.length}`);
         await client.connect();
         spinner.text = 'Connected to database';
         let allDefinitions = [];

package/dist/sync/seedGenerator.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSeedsFromRemote = generateSeedsFromRemote;
+const pg_1 = require("pg");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+/**
+ * 指定テーブルのデータをリモートDBから取得し、AI用シードJSONを生成
+ * @param options SeedGenOptions
+ */
+async function generateSeedsFromRemote(options) {
+    // tables.yaml読み込み
+    const yamlObj = js_yaml_1.default.load(fs_1.default.readFileSync(options.tablesYamlPath, 'utf8'));
+    if (!yamlObj || !Array.isArray(yamlObj.tables)) {
+        throw new Error('tables.yamlの形式が不正です。tables: [ ... ] で指定してください');
+    }
+    const tables = yamlObj.tables;
+    // 日時付きサブディレクトリ名生成（例: 20250705_1116_supatool）
+    const now = new Date();
+    const y = now.getFullYear();
+    const m = String(now.getMonth() + 1).padStart(2, '0');
+    const d = String(now.getDate()).padStart(2, '0');
+    const hh = String(now.getHours()).padStart(2, '0');
+    const mm = String(now.getMinutes()).padStart(2, '0');
+    const folderName = `${y}${m}${d}_${hh}${mm}_supatool`;
+    const outDir = path_1.default.join(options.outputDir, folderName);
+    // 出力ディレクトリ作成
+    if (!fs_1.default.existsSync(outDir)) {
+        fs_1.default.mkdirSync(outDir, { recursive: true });
+    }
+    // DB接続
+    const client = new pg_1.Client({ connectionString: options.connectionString });
+    await client.connect();
+    let processedCount = 0;
+    for (const tableFullName of tables) {
+        // スキーマ指定なし→public
+        let schema = 'public';
+        let table = tableFullName;
+        if (tableFullName.includes('.')) {
+            [schema, table] = tableFullName.split('.');
+        }
+        // データ取得
+        const res = await client.query(`SELECT * FROM "${schema}"."${table}"`);
+        const rows = res.rows;
+        // ファイル名
+        const fileName = `${table}_seed.json`;
+        const filePath = path_1.default.join(outDir, fileName);
+        // 出力JSON
+        const json = {
+            table: `${schema}.${table}`,
+            fetched_at: now.toISOString(),
+            fetched_by: 'supatool v0.3.5',
+            note: 'This data is a snapshot of the remote DB at the above time. For AI coding reference. You can update it by running the update command again.',
+            rows
+        };
+        fs_1.default.writeFileSync(filePath, JSON.stringify(json, null, 2), 'utf8');
+        processedCount++;
+    }
+    await client.end();
+    // llms.txtインデックス出力（supabase/seeds直下に毎回上書き）
+    const files = fs_1.default.readdirSync(outDir);
+    const seedFiles = files.filter(f => f.endsWith('_seed.json'));
+    let llmsTxt = `# AI seed data index (generated by supatool)\n`;
+    llmsTxt += `# fetched_at: ${now.toISOString()}\n`;
+    llmsTxt += `# folder: ${folderName}\n`;
+    for (const basename of seedFiles) {
+        const file = path_1.default.join(outDir, basename);
+        const content = JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+        // テーブルコメント（なければ空）
+        let tableComment = '';
+        try {
+            const [schema, table] = content.table.split('.');
+            const commentRes = await getTableComment(options.connectionString, schema, table);
+            if (commentRes)
+                tableComment = commentRes;
+        }
+        catch { }
+        llmsTxt += `${content.table}: ${basename} (${Array.isArray(content.rows) ? content.rows.length : 0} rows)`;
+        if (tableComment)
+            llmsTxt += ` # ${tableComment}`;
+        llmsTxt += `\n`;
+    }
+    const llmsPath = path_1.default.join(options.outputDir, 'llms.txt');
+    fs_1.default.writeFileSync(llmsPath, llmsTxt, 'utf8');
+    // 英語でまとめて出力
+    console.log(`Seed export completed. Processed tables: ${processedCount}`);
+    console.log(`llms.txt index written to: ${llmsPath}`);
+}
+// テーブルコメント取得ユーティリティ
+async function getTableComment(connectionString, schema, table) {
+    const client = new pg_1.Client({ connectionString });
+    await client.connect();
+    try {
+        const res = await client.query(`SELECT obj_description(c.oid) as comment FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'r'`, [table, schema]);
+        if (res.rows.length > 0 && res.rows[0].comment) {
+            return res.rows[0].comment;
+        }
+        return null;
+    }
+    finally {
+        await client.end();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supatool",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "A CLI tool for Supabase schema extraction and TypeScript CRUD generation with declarative database schema support.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",