supatool 0.1.22 → 0.3.0

package/dist/sync/fetchRemoteSchemas.js

@@ -0,0 +1,369 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRemoteSchemas = fetchRemoteSchemas;
+const pg_1 = require("pg");
+const dns = __importStar(require("dns"));
+const util_1 = require("util");
+const dnsLookup = (0, util_1.promisify)(dns.lookup);
+/**
+ * DDL文字列を正規化（空白・改行・タブを統一）
+ */
+function normalizeDDL(ddl) {
+    return ddl
+        .replace(/\s+/g, ' ') // 連続する空白文字を1つのスペースに
+        .replace(/;\s+/g, ';\n') // セミコロン後に改行
+        .trim(); // 前後の空白を削除
+}
+/**
+ * リモートSupabaseからスキーマを取得
+ */
+async function fetchRemoteSchemas(connectionString) {
+    const schemas = {};
+    // console.log('データベースに接続中...');
+    try {
+        // 接続文字列の基本チェック
+        if (!connectionString || !connectionString.startsWith('postgresql://')) {
+            throw new Error('無効な接続文字列です。postgresql://で始まる形式で指定してください。');
+        }
+        // URL解析して接続先を表示
+        const url = new URL(connectionString);
+        console.log(`接続先: ${url.hostname}:${url.port}`);
+        console.log(`ユーザー: ${url.username}`);
+        // パスワードに特殊文字が含まれている場合の対処
+        const decodedPassword = decodeURIComponent(url.password || '');
+        // 接続文字列を再構築（パスワードを適切にエンコード）
+        const encodedPassword = encodeURIComponent(decodedPassword);
+        // Session poolerのモードを明示的に指定
+        let reconstructedConnectionString = `postgresql://${url.username}:${encodedPassword}@${url.hostname}:${url.port}${url.pathname}`;
+        // Session poolingモードのパラメータを追加
+        const searchParams = new URLSearchParams(url.search);
+        searchParams.set('sslmode', 'require');
+        searchParams.set('application_name', 'supatool');
+        reconstructedConnectionString += `?${searchParams.toString()}`;
+        // IPv4を優先に変更
+        dns.setDefaultResultOrder('ipv4first');
+        // DNS解決テスト
+        try {
+            const addresses = await dns.promises.lookup(url.hostname, { all: true });
+        }
+        catch (dnsError) {
+            console.error('❌ DNS解決に失敗しました');
+            throw dnsError;
+        }
+        // Session pooler用の設定
+        const clientConfig = {
+            connectionString: reconstructedConnectionString,
+            ssl: {
+                rejectUnauthorized: false
+            },
+            // Session pooler用の追加設定
+            statement_timeout: 30000,
+            query_timeout: 30000,
+            connectionTimeoutMillis: 10000,
+            idleTimeoutMillis: 10000
+        };
+        console.log('Session pooler経由で接続中...');
+        let client;
+        try {
+            client = new pg_1.Client(clientConfig);
+            await client.connect();
+        }
+        catch (sslError) {
+            if (sslError instanceof Error && (sslError.message.includes('SASL') ||
+                sslError.message.includes('SCRAM') ||
+                sslError.message.includes('certificate') ||
+                sslError.message.includes('SELF_SIGNED_CERT'))) {
+                console.log('SSL接続不可のため、SSL無効化で再試行中...');
+                // SSL無効化バージョンを試行
+                const noSslConnectionString = reconstructedConnectionString.replace('sslmode=require', 'sslmode=disable');
+                const noSslConfig = {
+                    ...clientConfig,
+                    connectionString: noSslConnectionString,
+                    ssl: false
+                };
+                try {
+                    client = new pg_1.Client(noSslConfig);
+                    await client.connect();
+                    console.log('SSL無効化での接続に成功');
+                }
+                catch (noSslError) {
+                    if (noSslError instanceof Error && (noSslError.message.includes('SASL') || noSslError.message.includes('SCRAM'))) {
+                        console.log('Session poolerでSASLエラー継続。Direct connectionで再試行中...');
+                        // Direct connection (ポート5432) で再試行
+                        const directConnectionString = noSslConnectionString.replace('pooler.supabase.com:5432', 'supabase.co:5432');
+                        const directConfig = {
+                            ...noSslConfig,
+                            connectionString: directConnectionString
+                        };
+                        client = new pg_1.Client(directConfig);
+                        await client.connect();
+                        console.log('Direct connectionでの接続に成功');
+                    }
+                    else {
+                        throw noSslError;
+                    }
+                }
+            }
+            else {
+                throw sslError;
+            }
+        }
+        // 接続テストクエリ
+        const testResult = await client.query('SELECT version()');
+        // テーブル一覧を取得
+        const tablesResult = await client.query(`
+      SELECT tablename 
+      FROM pg_tables 
+      WHERE schemaname = 'public'
+      ORDER BY tablename
+    `);
+        console.log(`リモートテーブル：${tablesResult.rows.length}`);
+        // ローディングアニメーション用
+        const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let spinnerIndex = 0;
+        const startTime = Date.now();
+        const spinnerInterval = setInterval(() => {
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            process.stdout.write(`\r${spinner[spinnerIndex]} スキーマ取得中... ${elapsed}s`);
+            spinnerIndex = (spinnerIndex + 1) % spinner.length;
+        }, 100);
+        // 各テーブルのスキーマ情報を取得
+        for (const row of tablesResult.rows) {
+            const tableName = row.tablename;
+            // テーブルの最終更新時刻を取得（複数の方法を試行）
+            let timestamp = Math.floor(Date.now() / 1000); // デフォルト値
+            // pg_stat_user_tablesから取得
+            try {
+                const tableStatsResult = await client.query(`
+           SELECT 
+             EXTRACT(EPOCH FROM GREATEST(
+               COALESCE(last_vacuum, '1970-01-01'::timestamp),
+               COALESCE(last_autovacuum, '1970-01-01'::timestamp),
+               COALESCE(last_analyze, '1970-01-01'::timestamp),
+               COALESCE(last_autoanalyze, '1970-01-01'::timestamp)
+             ))::bigint as last_updated
+           FROM pg_stat_user_tables 
+           WHERE relname = $1 AND schemaname = 'public'
+         `, [tableName]);
+                if (tableStatsResult.rows.length > 0 && tableStatsResult.rows[0].last_updated > 0) {
+                    timestamp = tableStatsResult.rows[0].last_updated;
+                }
+                else {
+                    // デフォルトタイムスタンプ（十分に古い固定値）
+                    timestamp = Math.floor(new Date('2020-01-01').getTime() / 1000);
+                }
+            }
+            catch (statsError) {
+                // デフォルトタイムスタンプ（十分に古い固定値）
+                timestamp = Math.floor(new Date('2020-01-01').getTime() / 1000);
+            }
+            // カラム情報を取得
+            const columnsResult = await client.query(`
+        SELECT 
+          column_name,
+          data_type,
+          character_maximum_length,
+          is_nullable,
+          column_default
+        FROM information_schema.columns 
+        WHERE table_schema = 'public' 
+          AND table_name = $1
+        ORDER BY ordinal_position
+      `, [tableName]);
+            // 主キー情報を取得
+            const primaryKeyResult = await client.query(`
+        SELECT column_name
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu 
+          ON tc.constraint_name = kcu.constraint_name
+        WHERE tc.table_schema = 'public'
+          AND tc.table_name = $1
+          AND tc.constraint_type = 'PRIMARY KEY'
+        ORDER BY kcu.ordinal_position
+      `, [tableName]);
+            // CREATE TABLE文を生成
+            let ddl = `CREATE TABLE IF NOT EXISTS ${tableName} (\n`;
+            const columnDefs = [];
+            for (const col of columnsResult.rows) {
+                let colDef = `  ${col.column_name} ${col.data_type.toUpperCase()}`;
+                // 長さ指定
+                if (col.character_maximum_length) {
+                    colDef += `(${col.character_maximum_length})`;
+                }
+                // NOT NULL制約
+                if (col.is_nullable === 'NO') {
+                    colDef += ' NOT NULL';
+                }
+                // デフォルト値
+                if (col.column_default) {
+                    colDef += ` DEFAULT ${col.column_default}`;
+                }
+                columnDefs.push(colDef);
+            }
+            ddl += columnDefs.join(',\n');
+            // 主キー制約
+            if (primaryKeyResult.rows.length > 0) {
+                const pkColumns = primaryKeyResult.rows.map(row => row.column_name);
+                ddl += `,\n  PRIMARY KEY (${pkColumns.join(', ')})`;
+            }
+            // UNIQUE制約を取得してCREATE TABLE内に含める
+            const uniqueConstraintResult = await client.query(`
+        SELECT 
+          tc.constraint_name,
+          string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) as columns
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu 
+          ON tc.constraint_name = kcu.constraint_name
+        WHERE tc.table_schema = 'public'
+          AND tc.table_name = $1
+          AND tc.constraint_type = 'UNIQUE'
+        GROUP BY tc.constraint_name
+        ORDER BY tc.constraint_name
+      `, [tableName]);
+            // UNIQUE制約をCREATE TABLE内に追加
+            for (const unique of uniqueConstraintResult.rows) {
+                ddl += `,\n  CONSTRAINT ${unique.constraint_name} UNIQUE (${unique.columns})`;
+            }
+            // CHECK制約は一時的に無効化（NOT NULL制約と重複するため）
+            // const checkConstraintResult = await client.query(`...`);
+            // CHECK制約をCREATE TABLE内に追加は一時的に無効化
+            // for (const check of checkConstraintResult.rows) {
+            //   ddl += `,\n  CONSTRAINT ${check.constraint_name} CHECK ${check.check_clause}`;
+            // }
+            ddl += '\n);';
+            // 外部キー制約のみを別途生成
+            const foreignKeyResult = await client.query(`
+        SELECT 
+          tc.constraint_name,
+          kcu.column_name,
+          ccu.table_name AS foreign_table_name,
+          ccu.column_name AS foreign_column_name,
+          rc.delete_rule,
+          rc.update_rule
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu 
+          ON tc.constraint_name = kcu.constraint_name
+        JOIN information_schema.constraint_column_usage ccu 
+          ON ccu.constraint_name = tc.constraint_name
+        JOIN information_schema.referential_constraints rc 
+          ON tc.constraint_name = rc.constraint_name
+        WHERE tc.table_schema = 'public'
+          AND tc.table_name = $1
+          AND tc.constraint_type = 'FOREIGN KEY'
+        ORDER BY tc.constraint_name
+      `, [tableName]);
+            // 外部キー制約のみをALTER TABLE文として追加
+            for (const fk of foreignKeyResult.rows) {
+                ddl += `\n\nALTER TABLE ${tableName} ADD CONSTRAINT ${fk.constraint_name}`;
+                ddl += ` FOREIGN KEY (${fk.column_name})`;
+                ddl += ` REFERENCES ${fk.foreign_table_name} (${fk.foreign_column_name})`;
+                if (fk.delete_rule && fk.delete_rule !== 'NO ACTION') {
+                    ddl += ` ON DELETE ${fk.delete_rule}`;
+                }
+                if (fk.update_rule && fk.update_rule !== 'NO ACTION') {
+                    ddl += ` ON UPDATE ${fk.update_rule}`;
+                }
+                ddl += ';';
+            }
+            // インデックス情報を取得
+            const indexResult = await client.query(`
+        SELECT 
+          indexname,
+          indexdef
+        FROM pg_indexes 
+        WHERE schemaname = 'public' 
+          AND tablename = $1
+          AND indexname NOT LIKE '%_pkey'
+          AND indexname NOT IN (
+            SELECT tc.constraint_name 
+            FROM information_schema.table_constraints tc
+            WHERE tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
+          )
+        ORDER BY indexname
+      `, [tableName]);
+            // インデックスを追加
+            for (const idx of indexResult.rows) {
+                ddl += `\n\n${idx.indexdef};`;
+            }
+            // DDLを元の形式で保存
+            schemas[tableName] = {
+                ddl,
+                timestamp
+            };
+        }
+        // ローディングアニメーション停止
+        clearInterval(spinnerInterval);
+        const totalTime = Math.floor((Date.now() - startTime) / 1000);
+        process.stdout.write(`\rSchema fetch completed (${totalTime}s)                    \n`);
+        await client.end();
+    }
+    catch (error) {
+        console.error('❌ Remote schema fetch error:');
+        if (error instanceof Error) {
+            if (error.message.includes('ENOTFOUND')) {
+                console.error('🌐 DNS resolution error: Host not found');
+                console.error('💡 Check:');
+                console.error('   - Is your internet connection working?');
+                console.error('   - Is your Supabase project connection string correct?');
+            }
+            else if (error.message.includes('authentication failed')) {
+                console.error('🔐 Authentication error: Incorrect username or password');
+            }
+            else if (error.message.includes('SASL') || error.message.includes('SCRAM')) {
+                console.error('🔐 SASL authentication error: Password or connection settings issue');
+                console.error('💡 Session pooler connection checklist:');
+                console.error('   - Reset database password in Supabase dashboard');
+                console.error('   - Update connection string with new password');
+                console.error('   - URL encode special characters in password if needed');
+                console.error('   - Ensure project is not paused');
+                console.error('   - Supabase Dashboard → Settings → Database → Reset database password');
+            }
+            else if (error.message.includes('connect ETIMEDOUT')) {
+                console.error('⏰ Connection timeout: Cannot reach database server');
+            }
+            else {
+                console.error(`🐛 ${error.message}`);
+            }
+        }
+        console.error('\n📖 Session pooler connection setup:');
+        console.error('1. Supabase Dashboard → Settings → Database');
+        console.error('2. Select "Session pooler" tab');
+        console.error('3. Reset password (Reset database password)');
+        console.error('4. Set new connection string in .env.local');
+        throw error;
+    }
+    return schemas;
+}

package/dist/sync/generateMigration.js

@@ -0,0 +1,276 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMigrationFile = generateMigrationFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const diff_1 = require("diff");
+/**
+ * DDL差分からALTER TABLE文を生成
+ */
+function generateAlterStatements(tableName, fromDdl, toDdl) {
+    const statements = [];
+    const diff = (0, diff_1.diffLines)(fromDdl, toDdl);
+    // デバッグ情報削除 - シンプルな表示
+    // カラム名変更の検出用
+    const removedColumns = [];
+    const addedColumns = [];
+    for (const part of diff) {
+        if (part.added) {
+            // 追加された行をALTER TABLE文に変換
+            const lines = part.value.split('\n').filter(line => line.trim());
+            for (const line of lines) {
+                const trimmed = line.trim();
+                // カラム定義の追加を検出
+                if (trimmed.includes('  ') && !trimmed.startsWith('CREATE') && !trimmed.startsWith('PRIMARY') && !trimmed.startsWith('CONSTRAINT')) {
+                    const columnDef = trimmed.replace(/,$/, '').trim();
+                    const columnMatch = columnDef.match(/^(\w+)\s+(.+)$/);
+                    if (columnMatch) {
+                        const columnName = columnMatch[1];
+                        const columnType = columnMatch[2];
+                        addedColumns.push({ name: columnName, definition: columnType });
+                    }
+                }
+            }
+        }
+        else if (part.removed) {
+            // 削除された行をALTER TABLE文に変換  
+            const lines = part.value.split('\n').filter(line => line.trim());
+            for (const line of lines) {
+                const trimmed = line.trim();
+                // カラム定義の削除を検出
+                if (trimmed.includes('  ') && !trimmed.startsWith('CREATE') && !trimmed.startsWith('PRIMARY') && !trimmed.startsWith('CONSTRAINT')) {
+                    const columnDef = trimmed.replace(/,$/, '').trim();
+                    const columnMatch = columnDef.match(/^(\w+)\s+(.+)$/);
+                    if (columnMatch) {
+                        const columnName = columnMatch[1];
+                        const columnType = columnMatch[2];
+                        removedColumns.push({ name: columnName, definition: columnType });
+                    }
+                }
+            }
+        }
+    }
+    // カラム名変更の検出（型定義が同じで名前が違う場合）
+    const renames = [];
+    for (const removed of removedColumns) {
+        const matching = addedColumns.find(added => added.definition === removed.definition);
+        if (matching) {
+            renames.push({ from: removed.name, to: matching.name });
+            // 処理済みとしてマーク
+            removedColumns.splice(removedColumns.indexOf(removed), 1);
+            addedColumns.splice(addedColumns.indexOf(matching), 1);
+        }
+    }
+    // デバッグログ削除 - シンプルな表示
+    // RENAME COLUMN文を生成
+    for (const rename of renames) {
+        statements.push(`ALTER TABLE ${tableName} RENAME COLUMN ${rename.from} TO ${rename.to};`);
+    }
+    // 残りの削除されたカラム
+    for (const removed of removedColumns) {
+        statements.push(`ALTER TABLE ${tableName} DROP COLUMN ${removed.name};`);
+    }
+    // 残りの追加されたカラム
+    for (const added of addedColumns) {
+        statements.push(`ALTER TABLE ${tableName} ADD COLUMN ${added.name} ${added.definition};`);
+    }
+    return statements;
+}
+/**
+ * マイグレーションファイルを生成
+ */
+async function generateMigrationFile(tableName, fromDdl, toDdl, projectDir = '.') {
+    const migrationDir = path.join(projectDir, 'supabase', 'migrations');
+    // migrations ディレクトリを作成
+    if (!fs.existsSync(migrationDir)) {
+        fs.mkdirSync(migrationDir, { recursive: true });
+    }
+    // ALTER TABLE文を生成
+    const alterStatements = generateAlterStatements(tableName, fromDdl, toDdl);
+    if (alterStatements.length === 0) {
+        return await generateManualMigrationTemplate(tableName, fromDdl, toDdl, projectDir);
+    }
+    // タイムスタンプでファイル名を生成
+    const now = new Date();
+    const timestamp = now.toISOString()
+        .replace(/[-:]/g, '')
+        .replace(/\..+/, '')
+        .replace('T', '');
+    const filename = `${timestamp}_update_${tableName}.sql`;
+    const filepath = path.join(migrationDir, filename);
+    // マイグレーションファイルの内容を生成
+    const content = `-- Migration generated by supatool
+-- Table: ${tableName}
+-- Generated at: ${now.toISOString()}
+
+${alterStatements.join('\n')}
+`;
+    // ファイルを書き込み
+    fs.writeFileSync(filepath, content, 'utf-8');
+    console.log(`マイグレーションファイル生成: ${filename}`);
+    return filepath;
+}
+/**
+ * DDLからカラム定義を抽出
+ */
+function extractColumns(ddl) {
+    const columns = [];
+    // CREATE TABLE部分を抽出
+    const createTableMatch = ddl.match(/CREATE TABLE[^(]*\((.*)\);?/is);
+    if (!createTableMatch) {
+        return columns;
+    }
+    const tableContent = createTableMatch[1];
+    // カラム定義とCONSTRAINTを分離
+    const parts = tableContent.split(',').map(part => part.trim());
+    for (const part of parts) {
+        // CONSTRAINTやPRIMARY KEYは除外
+        if (part.match(/^(PRIMARY|CONSTRAINT|UNIQUE|FOREIGN|CHECK)/i)) {
+            continue;
+        }
+        // カラム名とデータ型を分離
+        const columnMatch = part.trim().match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s+(.+)$/);
+        if (columnMatch) {
+            const columnName = columnMatch[1];
+            const columnType = columnMatch[2];
+            columns.push({ name: columnName, definition: columnType });
+        }
+    }
+    return columns;
+}
+/**
+ * 差分からカラム変更を解析
+ */
+function analyzeDiffForTemplate(fromDdl, toDdl) {
+    // 各DDLからカラムを抽出
+    const fromColumns = extractColumns(fromDdl);
+    const toColumns = extractColumns(toDdl);
+    // 削除されたカラム（FROMにあってTOにない）
+    const removedColumns = fromColumns.filter(fromCol => !toColumns.some(toCol => toCol.name === fromCol.name));
+    // 追加されたカラム（TOにあってFROMにない）
+    const addedColumns = toColumns.filter(toCol => !fromColumns.some(fromCol => fromCol.name === toCol.name));
+    return { removedColumns, addedColumns };
+}
+/**
+ * 手動マイグレーションテンプレートを生成
+ */
+async function generateManualMigrationTemplate(tableName, fromDdl, toDdl, projectDir) {
+    const migrationDir = path.join(projectDir, 'supabase', 'migrations');
+    if (!fs.existsSync(migrationDir)) {
+        fs.mkdirSync(migrationDir, { recursive: true });
+    }
+    // 差分を解析
+    const { removedColumns, addedColumns } = analyzeDiffForTemplate(fromDdl, toDdl);
+    // タイムスタンプでファイル名を生成
+    const now = new Date();
+    const timestamp = now.toISOString()
+        .replace(/[-:]/g, '')
+        .replace(/\..+/, '')
+        .replace('T', '');
+    const filename = `${timestamp}_manual_update_${tableName}.sql`;
+    const filepath = path.join(migrationDir, filename);
+    // 実際の変更を基にテンプレートを生成
+    let migrationStatements = [];
+    // カラム名変更の可能性を検出
+    const potentialRenames = [];
+    for (const removed of removedColumns) {
+        const matching = addedColumns.find(added => added.definition === removed.definition);
+        if (matching) {
+            potentialRenames.push({
+                from: removed.name,
+                to: matching.name,
+                definition: removed.definition
+            });
+        }
+    }
+    // 残りの削除・追加
+    const remainingRemoved = removedColumns.filter(r => !potentialRenames.some(p => p.from === r.name));
+    const remainingAdded = addedColumns.filter(a => !potentialRenames.some(p => p.to === a.name));
+    // テンプレート文を生成（DROP → ADD → RENAME の順序）
+    if (remainingRemoved.length > 0) {
+        migrationStatements.push('-- Column removals:');
+        for (const removed of remainingRemoved) {
+            migrationStatements.push(`ALTER TABLE ${tableName} DROP COLUMN ${removed.name};`);
+        }
+    }
+    if (remainingAdded.length > 0) {
+        if (migrationStatements.length > 0)
+            migrationStatements.push('');
+        migrationStatements.push('-- Column additions:');
+        for (const added of remainingAdded) {
+            migrationStatements.push(`ALTER TABLE ${tableName} ADD COLUMN ${added.name} ${added.definition};`);
+        }
+    }
+    if (potentialRenames.length > 0) {
+        if (migrationStatements.length > 0)
+            migrationStatements.push('');
+        migrationStatements.push('-- Possible column renames:');
+        for (const rename of potentialRenames) {
+            migrationStatements.push(`ALTER TABLE ${tableName} RENAME COLUMN ${rename.from} TO ${rename.to};`);
+        }
+    }
+    // フォールバック: 何も検出されなかった場合
+    if (migrationStatements.length === 0) {
+        migrationStatements = [
+            `-- Manual migration for ${tableName}`,
+            `-- No specific changes detected, please edit manually`,
+            ``,
+            `-- ALTER TABLE ${tableName} RENAME COLUMN old_name TO new_name;`,
+            `-- ALTER TABLE ${tableName} ADD COLUMN new_column TYPE;`,
+            `-- ALTER TABLE ${tableName} DROP COLUMN old_column;`
+        ];
+    }
+    const content = `-- Manual migration for ${tableName}
+-- Edit this file and apply manually or using supabase CLI
+
+${migrationStatements.join('\n')}
+`;
+    fs.writeFileSync(filepath, content, 'utf-8');
+    console.log(`手動マイグレーションテンプレート生成: ${filename}`);
+    return filepath;
+}
+/**
+ * より高度な差分解析（カラム変更を検出）
+ */
+function analyzeColumnChanges(tableName, localDdl, remoteDdl) {
+    const statements = [];
+    // 簡単な例：カラム名の変更を検出
+    const localLines = localDdl.split('\n').map(line => line.trim()).filter(line => line);
+    const remoteLines = remoteDdl.split('\n').map(line => line.trim()).filter(line => line);
+    // カラムの型変更やデフォルト値変更などの高度な検出は今後実装
+    // 現在は基本的な追加/削除のみ対応
+    return statements;
+}

package/dist/sync/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sync"), exports);
+__exportStar(require("./fetchRemoteSchemas"), exports);
+__exportStar(require("./parseLocalSchemas"), exports);
+__exportStar(require("./writeSchema"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./config"), exports);