supatool 0.1.23 → 0.3.0

package/README.md

@@ -14,36 +14,88 @@ pnpm add -g supatool
 
 ## Usage
 
-1. Generate Supabase type definition file
+### 1. Extract Database Schema (NEW in v0.3.0)
 
+Extract and categorize all database objects from your Supabase project:
+
+```bash
+# Set connection string in environment (recommended)
+echo "SUPABASE_CONNECTION_STRING=postgresql://..." >> .env.local
+
+# Extract all database objects with AI-friendly index
+supatool extract --all -o supabase/schemas
+
+# Extract only tables and views
+supatool extract -o supabase/schemas
+
+# Extract specific tables with pattern
+supatool extract -t "user_*" -o supabase/schemas
+
+# Extract from specific schemas (comma-separated)
+supatool extract --all --schema public,auth,extensions -o supabase/schemas
+
+# Alternative: specify connection directly
+supatool extract --all -c "postgresql://..." -o supabase/schemas
+```
+
+**Output structure:**
 ```
-npx supabase gen types typescript --project-id your_project_ref --schema public > shared/types.ts
+supabase/schemas/
+├── index.md              # Human-readable index with comments
+├── llms.txt              # AI-friendly structured data with comments
+├── tables/               # Table definitions with comments
+├── views/                # View definitions with comments
+├── rls/                  # RLS policies
+└── rpc/                  # Functions & triggers
 ```
 
-2. Auto-generate CRUD code
+### 2. Generate CRUD Code
 
-```
+Generate TypeScript CRUD functions from Supabase types:
+
+```bash
+# Generate from Supabase type definitions
 supatool crud
+
+# Generate from schema SQL files  
+supatool gen:schema-crud --include-views --react-query
+
+# Generate from model YAML
+supatool gen:crud model.yaml
 ```
-- Output: `src/integrations/supabase/crud-autogen/`
 
-3. Subcommands
+**Output:** `src/integrations/supabase/crud-autogen/`
+
+### 3. Environment Configuration
+
+For security and convenience, set your connection string in environment variables:
+
+```bash
+# Create .env.local file with your connection details
+cat > .env.local << EOF
+SUPABASE_CONNECTION_STRING=postgresql://user:password@host:port/database
+# Alternative: use DATABASE_URL
+DATABASE_URL=postgresql://user:password@host:port/database
+EOF
+
+# Now you can run commands without -c flag
+supatool extract --all -o supabase/schemas
+```
 
-For more extensible usage, execute with subcommands:
+**Supported environment variables:**
+- `SUPABASE_CONNECTION_STRING` (preferred)
+- `DATABASE_URL` (fallback)
+- `SUPATOOL_MAX_CONCURRENT` (max concurrent table processing, default: 20, max: 50)
 
-- Show help text for all commands:
-  ```sh
-  supatool help
-  ```
+### 4. Additional Commands
 
-- Specify input and output folder:
-  ```sh
-  supatool -i path/to/type -o path/to/export
-  ```
+```bash
+# Show help for all commands
+supatool help
 
-For detailed usage, see:
-- [src/bin/helptext.ts](./src/bin/helptext.ts) (for development)
-- [dist/bin/helptext.js](./dist/bin/helptext.js) (for npm package)
+# Specify custom input/output paths
+supatool crud -i path/to/types -o path/to/output
+```
 
 ## Note: Supabase Client Requirement
 
@@ -56,22 +108,41 @@ import { createClient } from '@supabase/supabase-js'
 export const supabase = createClient('YOUR_SUPABASE_URL', 'YOUR_SUPABASE_ANON_KEY')
 ```
 
-## VSCode/Cursor: Run Supabase CLI and supatool together
+## VSCode/Cursor Integration
 
-You can add a task to `.vscode/tasks.json` to run both commands at once:
+Add these tasks to `.vscode/tasks.json` for quick access:
 
-> **Note:**
-> After installing supatool, please restart VSCode (or your terminal) before using the task, so that the new command is recognized.
+> **Note:** Restart VSCode/Cursor after installing supatool to ensure the command is recognized.
 
 ```json
 {
   "version": "2.0.0",
   "tasks": [
     {
-      "label": "Generate Supabase types and CRUD",
+      "label": "Extract Schema and Generate CRUD",
+      "type": "shell",
+      "command": "supatool extract --all -o supabase/schemas && supatool gen:schema-crud --react-query",
+      "group": "build",
+      "dependsOn": "setup-env"
+    },
+    {
+      "label": "setup-env",
       "type": "shell",
-      "command": "mkdir -p shared && npx supabase gen types typescript --project-id your_project_id --schema public > shared/types.ts && supatool crud --force",
+      "command": "echo 'Ensure SUPABASE_CONNECTION_STRING is set in .env.local'",
       "group": "build"
+    },
+    {
+      "label": "Generate Types and CRUD (Legacy)",
+      "type": "shell", 
+      "command": "mkdir -p shared && npx supabase gen types typescript --project-id ${input:projectId} --schema public > shared/types.ts && supatool crud --force",
+      "group": "build"
+    }
+  ],
+  "inputs": [
+    {
+      "id": "projectId", 
+      "description": "Supabase project ID",
+      "default": "your_project_id"
     }
   ]
 }
@@ -128,4 +199,135 @@ For more details, see the project on GitHub: [https://github.com/idea-garage/sup
 
 ## Acknowledgements
 
-This project is inspired by and made possible thanks to the amazing work of [Supabase](https://supabase.com/).
+This project is inspired by and made possible thanks to the amazing work of [Supabase](https://supabase.com/).
+
+## Complete Workflow Examples
+
+### Database-First Development
+
+Extract your existing database schema and generate CRUD code using [Supabase's declarative schema workflow](https://supabase.com/docs/guides/local-development/declarative-database-schemas):
+
+```bash
+# 1. Set connection string in .env.local
+echo "SUPABASE_CONNECTION_STRING=postgresql://..." >> .env.local
+
+# 2. Extract all database objects to supabase/schemas (declarative schema format)
+supatool extract --all -o supabase/schemas
+
+# 3. Generate migrations from declarative schema
+supabase db diff -f initial_schema
+
+# 4. Generate TypeScript types with Supabase CLI  
+npx supabase gen types typescript --local > src/types/database.ts
+
+# 5. Generate CRUD functions with React Query support
+supatool gen:schema-crud --include-views --react-query
+```
+
+### Model-First Development
+
+Start from YAML model definitions:
+
+```bash
+# 1. Create model definition
+supatool create model.yaml
+
+# 2. Generate everything from model
+supatool gen:all model.yaml
+```
+
+### Extract Command Options
+
+Extract database objects in Supabase declarative schema format:
+
+```bash
+# Recommended: Set connection in .env.local first
+echo "SUPABASE_CONNECTION_STRING=postgresql://..." >> .env.local
+
+# Extract all database objects to categorized directories (recommended)
+supatool extract --all -o supabase/schemas
+# Output: supabase/schemas/{index.md,tables/,views/,rls/,rpc/}
+# Compatible with: supabase db diff
+
+# Extract only tables and views
+supatool extract -o supabase/schemas  
+# Output: supabase/schemas/{index.md,tables/,views/}
+
+# Extract to single directory (for simple projects)
+supatool extract --no-separate -o supabase/schemas
+# Output: supabase/schemas/{index.md,*.sql}
+
+# Extract with pattern matching
+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
+```
+
+## 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
+
+## Database Comments
+
+Supatool automatically extracts and includes PostgreSQL comments in all generated files. Comments enhance documentation and AI understanding of your schema.
+
+### Adding Comments to Your Database
+
+```sql
+-- Table comments
+COMMENT ON TABLE users IS 'User account information and authentication data';
+
+-- 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';
+```
+
+### Comment Integration
+
+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
+
+**Example output:**
+```markdown
+## Tables
+- [users](tables/users.sql) - User account information and authentication data
+- [posts](tables/posts.sql) - User-generated content and blog posts
+```
+
+## Changelog
+
+### v0.3.0
+- **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
+
+### v0.2.0
+- Added `gen:` commands for code and schema generation
+- Enhanced `create` command  
+- Introduced model schema support (`schemas/supatool-data.schema.ts`)

package/dist/bin/helptext.js

@@ -1,36 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.helpText = void 0;
+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 - Generate TypeScript CRUD code from Supabase type definitions
+Supatool CLI - Supabase database schema extraction and TypeScript CRUD generation
 
 Usage:
-  supatool crud [options]
-  supatool help
+  supatool <command> [options]
 
 Commands:
-  crud    Generate CRUD code
-  help    Show help
+  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
+  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
+  gen:sql            Generate SQL (tables, relations, RLS/security) from model YAML
+  gen:rls            Generate RLS/security SQL from model YAML
+  gen:all            Generate all outputs from model YAML
+  create             Generate a template model YAML
+  config:init        Generate configuration template
+  help               Show help
 
-Options:
-  -i, --import <path>   Import path for type definitions (default: shared/)
-  -e, --export <path>   Output path for CRUD code (default: src/integrations/supabase/)
-  -t, --tables <names>  Generate code for specific tables only (comma separated, e.g. table1,table2)
-  -f, --force           Overwrite output folder without confirmation
-  -h, --help            Show help
-  -V, --version         Show version
+Extract 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
-    - Import path: shared/
-    - Export path: src/integrations/supabase/
 
-  supatool crud -i path/to/import -e path/to/export
-    - Import path: path/to/import
-    - Export path: path/to/export
+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
+`;
+// Model Schema Usage
+exports.modelSchemaHelp = `
+Model Schema Usage (schemas/supatool-data.schema.ts):
+
+- Import in TypeScript:
+  import { SUPATOOL_MODEL_SCHEMA } from 'supatool/schemas/supatool-data.schema';
+
+- Validate with ajv:
+  import Ajv from 'ajv';
+  const ajv = new Ajv();
+  const validate = ajv.compile(SUPATOOL_MODEL_SCHEMA);
+  const data = /* your YAML/JSON parsed object */;
+  if (!validate(data)) {
+    console.error(validate.errors);
+  } else {
+    console.log('Valid!');
+  }
 
-  supatool crud -t users,posts
-    - Only generate for users and posts tables
+- Use with AI:
+  const schemaJson = JSON.stringify(SUPATOOL_MODEL_SCHEMA, null, 2);
+  // Pass schemaJson to your AI prompt or API
 `;

package/dist/bin/supatool.js

@@ -1,50 +1,201 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 // CLI entry point
 // Subcommand support with commander
 const commander_1 = require("commander");
 const index_1 = require("../index");
-const helptext_js_1 = require("./helptext.js"); // Import help text from external file
+const helptext_1 = require("./helptext"); // Import help text from external file
 const package_json_1 = require("../../package.json");
+const modelParser_1 = require("../parser/modelParser");
+const docGenerator_1 = require("../generator/docGenerator");
+const typeGenerator_1 = require("../generator/typeGenerator");
+const crudGenerator_1 = require("../generator/crudGenerator");
+const sqlGenerator_1 = require("../generator/sqlGenerator");
+const rlsGenerator_1 = require("../generator/rlsGenerator");
+const sync_1 = require("../sync");
+const definitionExtractor_1 = require("../sync/definitionExtractor");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const program = new commander_1.Command();
 program
     .name('supatool')
     .description('Supatool CLI')
     .version(package_json_1.version);
-// crud subcommand
+// extract command
 program
-    .command('crud')
-    .description('Generate CRUD types')
-    .option('-i, --import <path>', 'Import path for type definitions', 'shared/')
-    .option('-e, --export <path>', 'Output path for CRUD code', 'src/integrations/supabase/')
-    .option('-t, --tables <tables>', 'Generate only for specific tables (comma separated)')
-    .option('-f, --force', 'Force overwrite output folder without confirmation')
-    .action((options) => {
-    // Reflect command line arguments to process.argv (for main() reuse)
-    const args = process.argv.slice(0, 2);
-    if (options.import) {
-        args.push('-i', options.import);
+    .command('extract')
+    .description('Extract and categorize database objects from Supabase')
+    .option('-c, --connection <string>', 'Supabase connection string')
+    .option('-o, --output-dir <path>', 'Output directory', './supabase/schemas')
+    .option('-t, --tables <pattern>', 'Table pattern with wildcards', '*')
+    .option('--tables-only', 'Extract only table definitions')
+    .option('--views-only', 'Extract only view definitions')
+    .option('--all', 'Extract all DB objects (tables, views, RLS, functions, triggers, cron, types)')
+    .option('--no-separate', 'Output all objects in same directory')
+    .option('--schema <schemas>', 'Target schemas, comma-separated (default: public)')
+    .option('--config <path>', 'Configuration file path')
+    .option('-f, --force', 'Force overwrite without confirmation')
+    .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 {
+        // --schema オプションの処理
+        let schemas = ['public']; // デフォルト
+        if (options.schema) {
+            schemas = options.schema.split(',').map((s) => s.trim());
+        }
+        await (0, definitionExtractor_1.extractDefinitions)({
+            connectionString: config.connectionString,
+            outputDir: options.outputDir,
+            separateDirectories: options.separate !== false,
+            tablesOnly: options.tablesOnly,
+            viewsOnly: options.viewsOnly,
+            all: options.all,
+            tablePattern: options.tables,
+            force: options.force,
+            schemas: schemas
+        });
     }
-    if (options.export) {
-        args.push('-e', options.export);
+    catch (error) {
+        console.error('⚠️ Extraction error:', error);
+        process.exit(1);
     }
-    if (options.force) {
-        args.push('--force');
+});
+// config:init サブコマンド
+program
+    .command('config:init')
+    .description('設定ファイル雛形を生成')
+    .option('-o, --out <path>', '出力先パス', 'supatool.config.json')
+    .action((options) => {
+    (0, sync_1.createConfigTemplate)(options.out);
+});
+// gen:types サブコマンド
+program
+    .command('gen:types <modelPath>')
+    .description('モデルYAMLからTypeScript型定義を生成')
+    .option('-o, --out <path>', '出力先パス', 'docs/generated/types.ts')
+    .action((modelPath, options) => {
+    const model = (0, modelParser_1.parseModelYaml)(modelPath);
+    (0, typeGenerator_1.generateTypesFromModel)(model, options.out);
+    console.log('TypeScript型定義を出力:', options.out);
+});
+// gen:crud サブコマンド
+program
+    .command('gen:crud <modelPath>')
+    .description('Generate CRUD TypeScript code from model YAML')
+    .option('-o, --out <dir>', '出力先ディレクトリ', 'docs/generated/crud')
+    .action((modelPath, options) => {
+    const model = (0, modelParser_1.parseModelYaml)(modelPath);
+    (0, crudGenerator_1.generateCrudFromModel)(model, options.out);
+    console.log('Generated CRUD TypeScript code:', options.out);
+});
+// gen:docs サブコマンド
+program
+    .command('gen:docs <modelPath>')
+    .description('モデルYAMLからドキュメント(Markdown)を生成')
+    .option('-o, --out <path>', 'テーブル定義書出力先', 'docs/generated/table-doc.md')
+    .action((modelPath, options) => {
+    const model = (0, modelParser_1.parseModelYaml)(modelPath);
+    (0, docGenerator_1.generateTableDocMarkdown)(model, options.out);
+    (0, docGenerator_1.generateRelationsMarkdown)(model, 'docs/generated/relations.md');
+    console.log('テーブル定義書を出力:', options.out);
+    console.log('リレーション一覧を出力: docs/generated/relations.md');
+});
+// gen:sql サブコマンド
+program
+    .command('gen:sql <modelPath>')
+    .description('モデルYAMLからテーブル・リレーション・RLS/セキュリティSQLを一括生成')
+    .option('-o, --out <path>', '出力先パス', 'docs/generated/schema.sql')
+    .action((modelPath, options) => {
+    const model = (0, modelParser_1.parseModelYaml)(modelPath);
+    // 一時ファイルに個別出力
+    const tmpSchema = 'docs/generated/.tmp_schema.sql';
+    const tmpRls = 'docs/generated/.tmp_rls.sql';
+    (0, sqlGenerator_1.generateSqlFromModel)(model, tmpSchema);
+    (0, rlsGenerator_1.generateRlsSqlFromModel)(model, tmpRls);
+    // 結合して1ファイルにまとめる
+    const schema = fs_1.default.readFileSync(tmpSchema, 'utf-8');
+    const rls = fs_1.default.readFileSync(tmpRls, 'utf-8');
+    fs_1.default.writeFileSync(options.out, schema + '\n' + rls);
+    fs_1.default.unlinkSync(tmpSchema);
+    fs_1.default.unlinkSync(tmpRls);
+    console.log('テーブル・リレーション・RLS/セキュリティSQLを一括出力:', options.out);
+});
+// gen:rls サブコマンド
+program
+    .command('gen:rls <modelPath>')
+    .description('モデルYAMLからRLS/セキュリティポリシーSQLを生成')
+    .option('-o, --out <path>', '出力先パス', 'docs/generated/rls.sql')
+    .action((modelPath, options) => {
+    const model = (0, modelParser_1.parseModelYaml)(modelPath);
+    (0, rlsGenerator_1.generateRlsSqlFromModel)(model, options.out);
+    console.log('RLS/セキュリティポリシーSQLを出力:', options.out);
+});
+// gen:all サブコマンド
+program
+    .command('gen:all <modelPath>')
+    .description('モデルYAMLから全て一括生成')
+    .action((modelPath) => {
+    const model = (0, modelParser_1.parseModelYaml)(modelPath);
+    (0, typeGenerator_1.generateTypesFromModel)(model, 'docs/generated/types.ts');
+    (0, crudGenerator_1.generateCrudFromModel)(model, 'docs/generated/crud');
+    (0, docGenerator_1.generateTableDocMarkdown)(model, 'docs/generated/table-doc.md');
+    (0, docGenerator_1.generateRelationsMarkdown)(model, 'docs/generated/relations.md');
+    console.log('TypeScript型定義を出力: docs/generated/types.ts');
+    console.log('CRUD関数TypeScriptコードを出力: docs/generated/crud/');
+    console.log('テーブル定義書を出力: docs/generated/table-doc.md');
+    console.log('リレーション一覧を出力: docs/generated/relations.md');
+});
+// create サブコマンド
+program
+    .command('create <template>')
+    .description('テンプレートYAML雛形を生成')
+    .option('-o, --out <path>', '出力先パス', 'docs/model-schema-example.yaml')
+    .action((template, options) => {
+    const srcPath = path_1.default.join(__dirname, '../templates/yaml', `${template}.yaml`);
+    const destPath = options.out;
+    if (!fs_1.default.existsSync(srcPath)) {
+        console.error(`テンプレートが見つかりません: ${srcPath}`);
+        process.exit(1);
     }
-    process.argv = args;
+    fs_1.default.copyFileSync(srcPath, destPath);
+    console.log(`テンプレート雛形を生成: ${destPath}`);
+});
+// crud コマンド（Supabase型定義→CRUD生成）
+program
+    .command('crud')
+    .description('Supabase型定義(TypeScript)からCRUD関数TypeScriptコードを生成')
+    .option('-i, --input <path>', '型定義の入力パス', 'shared/')
+    .option('-o, --output <path>', 'CRUDコード出力先', 'src/integrations/supabase/')
+    .option('-t, --tables <names>', '生成対象テーブル（カンマ区切り）')
+    .option('-f, --force', '出力先を強制上書き')
+    .action((options) => {
+    // コマンドライン引数をmain()に渡すため、process.argvをそのまま利用
     (0, index_1.main)();
 });
-// help subcommand
+// helpサブコマンド
 program
     .command('help')
     .description('Show help')
     .action(() => {
-    console.log(helptext_js_1.helpText);
+    console.log(helptext_1.helpText);
 });
 // If no subcommand is specified, show helpText only (do not call main)
 if (!process.argv.slice(2).length) {
-    console.log(helptext_js_1.helpText);
+    console.log(helptext_1.helpText);
     process.exit(0);
 }
 program.parse(process.argv);

package/dist/generator/client.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supabase = void 0;
+// Supabaseクライアント定義（自動生成/手動編集可）
+// 日本語コメント
+const supabase_js_1 = require("@supabase/supabase-js");
+const supabaseUrl = process.env.SUPABASE_URL || '';
+const supabaseKey = process.env.SUPABASE_KEY || '';
+exports.supabase = (0, supabase_js_1.createClient)(supabaseUrl, supabaseKey);