supatool 0.1.23 → 0.3.0

package/dist/sync/migrationRunner.js

@@ -0,0 +1,271 @@
+"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.runMigrationsUp = runMigrationsUp;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pg_1 = require("pg");
+/**
+ * Supabaseの実際のマイグレーション管理テーブルを特定
+ * ソース: https://github.com/supabase/supabase
+ */
+async function findMigrationTable(client) {
+    // Supabaseソースコードに基づく実際のテーブル候補
+    const possibleTables = [
+        'supabase_migrations.schema_migrations',
+        '_supabase_migrations.schema_migrations',
+        'supabase_migrations.migrations',
+        '_supabase_migrations.migrations',
+        '_supabase.migrations',
+        'supabase.schema_migrations',
+        'public.schema_migrations'
+    ];
+    console.log('🔍 Supabaseマイグレーション管理テーブルを検索中...');
+    for (const tableName of possibleTables) {
+        try {
+            const schema = tableName.split('.')[0];
+            const table = tableName.split('.')[1];
+            const result = await client.query(`
+        SELECT EXISTS (
+          SELECT FROM information_schema.tables 
+          WHERE table_schema = $1 AND table_name = $2
+        );
+      `, [schema, table]);
+            if (result.rows[0].exists) {
+                console.log(`✅ 発見: ${tableName}`);
+                // テーブル構造も確認
+                try {
+                    const columnsResult = await client.query(`
+            SELECT column_name, data_type 
+            FROM information_schema.columns 
+            WHERE table_schema = $1 AND table_name = $2
+            ORDER BY ordinal_position;
+          `, [schema, table]);
+                    console.log(`📋 カラム構造:`, columnsResult.rows.map(r => `${r.column_name}:${r.data_type}`).join(', '));
+                }
+                catch (err) {
+                    // カラム構造確認失敗は無視
+                }
+                return tableName;
+            }
+        }
+        catch (error) {
+            // テーブルが存在しない場合は続行
+        }
+    }
+    console.log('❌ Supabaseマイグレーション管理テーブルが見つかりません');
+    return null;
+}
+/**
+ * 適用済みマイグレーションを取得（既存テーブル使用）
+ */
+async function getAppliedMigrations(client) {
+    const migrationTable = await findMigrationTable(client);
+    if (!migrationTable) {
+        console.log('⚠️ マイグレーション管理テーブルが見つからないため、全て未適用として扱います');
+        return new Set();
+    }
+    try {
+        const result = await client.query(`
+      SELECT version FROM ${migrationTable} ORDER BY inserted_at
+    `);
+        console.log(`📋 適用済みマイグレーション: ${result.rows.length} 個`);
+        return new Set(result.rows.map(row => row.version));
+    }
+    catch (error) {
+        console.log('⚠️ マイグレーション履歴の取得に失敗、全て未適用として扱います');
+        return new Set();
+    }
+}
+/**
+ * マイグレーションファイルをスキャン
+ */
+function scanMigrationFiles(migrationsDir) {
+    if (!fs.existsSync(migrationsDir)) {
+        console.log(`📁 マイグレーションディレクトリが見つかりません: ${migrationsDir}`);
+        return [];
+    }
+    const files = fs.readdirSync(migrationsDir)
+        .filter(file => file.endsWith('.sql'))
+        .sort(); // タイムスタンプ順に並び替え
+    return files.map(filename => {
+        const filepath = path.join(migrationsDir, filename);
+        const match = filename.match(/^(\d{14})_(.+)\.sql$/);
+        return {
+            filename,
+            filepath,
+            timestamp: match ? match[1] : '',
+            name: match ? match[2] : filename.replace('.sql', '')
+        };
+    });
+}
+/**
+ * SQLファイルの内容をクリーンアップ
+ */
+function cleanSqlContent(content) {
+    return content
+        .split('\n')
+        .filter(line => !line.trim().startsWith('--')) // コメント行を除去
+        .join('\n')
+        .trim();
+}
+/**
+ * マイグレーションファイルを適用
+ */
+async function applyMigration(client, migration, projectDir) {
+    try {
+        console.log(`⚡ 適用中: ${migration.filename}`);
+        const content = fs.readFileSync(migration.filepath, 'utf-8');
+        const cleanContent = cleanSqlContent(content);
+        if (!cleanContent) {
+            console.log(`⚠️  空のマイグレーションファイル: ${migration.filename}`);
+            return false;
+        }
+        // トランザクション内で実行
+        await client.query('BEGIN');
+        try {
+            // マイグレーションSQLを実行
+            await client.query(cleanContent);
+            // 既存のマイグレーション管理テーブルに記録（テーブルが存在する場合のみ）
+            const migrationTable = await findMigrationTable(client);
+            if (migrationTable) {
+                await client.query(`
+          INSERT INTO ${migrationTable} (version, inserted_at) 
+          VALUES ($1, NOW())
+          ON CONFLICT (version) DO NOTHING
+        `, [migration.timestamp]);
+            }
+            await client.query('COMMIT');
+            console.log(`✅ 成功: ${migration.filename}`);
+            return true;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+    }
+    catch (error) {
+        console.error(`❌ 失敗: ${migration.filename}`);
+        if (error instanceof Error) {
+            console.error(`   エラー: ${error.message}`);
+        }
+        return false;
+    }
+}
+/**
+ * 保留中のマイグレーションを適用
+ */
+async function runMigrationsUp(connectionString, projectDir = '.') {
+    const migrationsDir = path.join(projectDir, 'supabase', 'migrations');
+    // PostgreSQL接続（fetchRemoteSchemas.tsと同じ接続ロジックを使用）
+    console.log('データベースに接続中...');
+    const url = new URL(connectionString);
+    console.log(`接続先: ${url.hostname}:${url.port}`);
+    let client;
+    try {
+        // 接続試行（fetchRemoteSchemas.tsと同じフォールバック戦略）
+        const clientConfig = {
+            connectionString,
+            ssl: { rejectUnauthorized: false },
+            statement_timeout: 30000,
+            query_timeout: 30000,
+            connectionTimeoutMillis: 10000,
+            idleTimeoutMillis: 10000
+        };
+        try {
+            client = new pg_1.Client(clientConfig);
+            await client.connect();
+        }
+        catch (sslError) {
+            console.log('SSL接続失敗、SSL無効で再試行中...');
+            const noSslConnectionString = connectionString.replace('sslmode=require', 'sslmode=disable');
+            client = new pg_1.Client({
+                ...clientConfig,
+                connectionString: noSslConnectionString,
+                ssl: false
+            });
+            await client.connect();
+        }
+        console.log('✅ データベース接続成功');
+        // マイグレーションファイルをスキャン
+        const migrations = scanMigrationFiles(migrationsDir);
+        if (migrations.length === 0) {
+            console.log('📝 マイグレーションファイルが見つかりません');
+            return;
+        }
+        // 適用済みマイグレーションを取得
+        const appliedMigrations = await getAppliedMigrations(client);
+        // 未適用のマイグレーションをフィルタ（タイムスタンプで比較）
+        const pendingMigrations = migrations.filter(m => !appliedMigrations.has(m.timestamp));
+        if (pendingMigrations.length === 0) {
+            console.log('🎉 すべてのマイグレーションが適用済みです');
+            return;
+        }
+        console.log(`📋 ${pendingMigrations.length} 個の未適用マイグレーションが見つかりました:`);
+        pendingMigrations.forEach(m => {
+            console.log(`   - ${m.filename}`);
+        });
+        // マイグレーションを順次適用
+        let successCount = 0;
+        let failCount = 0;
+        for (const migration of pendingMigrations) {
+            const success = await applyMigration(client, migration, projectDir);
+            if (success) {
+                successCount++;
+            }
+            else {
+                failCount++;
+                break; // エラーが発生したら停止
+            }
+        }
+        console.log(`\n📊 マイグレーション完了:`);
+        console.log(`   成功: ${successCount} 個`);
+        if (failCount > 0) {
+            console.log(`   失敗: ${failCount} 個`);
+        }
+    }
+    catch (error) {
+        console.error('❌ マイグレーション実行エラー:');
+        if (error instanceof Error) {
+            console.error(error.message);
+        }
+        throw error;
+    }
+    finally {
+        if (client) {
+            await client.end();
+        }
+    }
+}

package/dist/sync/parseLocalSchemas.js

@@ -0,0 +1,97 @@
+"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.parseLocalSchemas = parseLocalSchemas;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * DDL文字列を正規化（空白・改行・タブを統一）
+ */
+function normalizeDDL(ddl) {
+    return ddl
+        .replace(/\s+/g, ' ') // 連続する空白文字を1つのスペースに
+        .replace(/;\s+/g, ';\n') // セミコロン後に改行
+        .trim(); // 前後の空白を削除
+}
+/**
+ * ローカルSQLファイルからスキーマを解析
+ */
+async function parseLocalSchemas(schemaDir) {
+    const schemas = {};
+    if (!fs.existsSync(schemaDir)) {
+        return schemas;
+    }
+    const files = fs.readdirSync(schemaDir);
+    for (const file of files) {
+        if (!file.endsWith('.sql'))
+            continue;
+        const filePath = path.join(schemaDir, file);
+        const stats = fs.statSync(filePath);
+        const fileContent = fs.readFileSync(filePath, 'utf-8');
+        // ファイル名からテーブル名を取得（.sqlを除く）
+        const tableName = path.basename(file, '.sql');
+        // ファイル内のコメントからタイムスタンプを抽出
+        let timestamp = Math.floor(stats.mtime.getTime() / 1000); // フォールバック
+        const timestampMatch = fileContent.match(/-- Remote last updated: (.+)/);
+        if (timestampMatch) {
+            try {
+                const dateStr = timestampMatch[1];
+                const parsedDate = new Date(dateStr);
+                if (!isNaN(parsedDate.getTime())) {
+                    timestamp = Math.floor(parsedDate.getTime() / 1000);
+                }
+            }
+            catch (error) {
+                // エラーの場合はファイル更新日時を使用
+            }
+        }
+        // DDL部分のみを抽出（コメント行と空白行を完全に除外）
+        const ddlLines = fileContent.split('\n').filter(line => {
+            const trimmed = line.trim();
+            return trimmed && !trimmed.startsWith('--');
+        });
+        const rawDDL = ddlLines.join('\n').trim();
+        // DDLを正規化
+        const ddl = normalizeDDL(rawDDL);
+        schemas[tableName] = {
+            ddl: rawDDL,
+            normalizedDdl: normalizeDDL(rawDDL),
+            timestamp,
+            fileTimestamp: Math.floor(stats.mtime.getTime() / 1000),
+            filePath
+        };
+    }
+    return schemas;
+}

package/dist/sync/sync.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncAllTables = syncAllTables;
+const parseLocalSchemas_1 = require("./parseLocalSchemas");
+const fetchRemoteSchemas_1 = require("./fetchRemoteSchemas");
+const writeSchema_1 = require("./writeSchema");
+const generateMigration_1 = require("./generateMigration");
+const diff_1 = require("diff");
+const utils_1 = require("./utils");
+// グローバル承認状態（writeSchema.tsと共有）
+let globalApproveAll = false;
+/**
+ * DDL文字列を正規化（空白・改行・タブを統一）
+ */
+function normalizeDDL(ddl) {
+    return ddl
+        .replace(/\s+/g, ' ') // 連続する空白文字を1つのスペースに
+        .replace(/;\s+/g, ';\n') // セミコロン後に改行
+        .trim(); // 前後の空白を削除
+}
+/**
+ * SQLを見やすく整形
+ */
+function formatSQL(sql) {
+    return sql
+        .replace(/,\s*/g, ',\n  ') // カンマ後に改行とインデント
+        .replace(/\(\s*/g, ' (\n  ') // 開き括弧後に改行とインデント
+        .replace(/\s*\)/g, '\n)') // 閉じ括弧前に改行
+        .replace(/\bCREATE\s+TABLE\b/g, '\nCREATE TABLE') // CREATE TABLE前に改行
+        .replace(/\bPRIMARY\s+KEY\b/g, '\n  PRIMARY KEY') // PRIMARY KEY前に改行とインデント
+        .replace(/;\s*/g, ';\n') // セミコロン後に改行
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line)
+        .join('\n');
+}
+/**
+ * すべてのテーブルスキーマを同期
+ */
+async function syncAllTables({ connectionString, schemaDir, tablePattern = '*', force = false }) {
+    // 承認状態をリセット
+    (0, writeSchema_1.resetApprovalState)();
+    const localSchemas = await (0, parseLocalSchemas_1.parseLocalSchemas)(schemaDir);
+    const remoteSchemas = await (0, fetchRemoteSchemas_1.fetchRemoteSchemas)(connectionString);
+    const allTables = new Set([...Object.keys(localSchemas), ...Object.keys(remoteSchemas)]);
+    const remoteTables = new Set(Object.keys(remoteSchemas));
+    // 存在しないテーブルのファイルをバックアップ
+    await (0, writeSchema_1.backupOrphanedFiles)(schemaDir, remoteTables, force);
+    for (const tableName of allTables) {
+        if (!(0, utils_1.wildcardMatch)(tableName, tablePattern)) {
+            continue;
+        }
+        const local = localSchemas[tableName];
+        const remote = remoteSchemas[tableName];
+        if (local && !remote) {
+            console.log(`[${tableName}] ローカルのみ - リモートに存在しません（バックアップ済み）`);
+        }
+        else if (!local && remote) {
+            console.log(`[${tableName}] リモートのみ - スキーマを取得`);
+            const success = await (0, writeSchema_1.writeSchemaToFile)(remote.ddl, schemaDir, remote.timestamp, `${tableName}.sql`, tableName, force);
+            if (success) {
+                console.log(`[${tableName}] スキーマファイルを作成しました`);
+            }
+        }
+        else if (local && remote) {
+            // 最初にDDLの差分をチェック
+            const normalizedLocal = local.normalizedDdl;
+            const normalizedRemote = normalizeDDL(remote.ddl);
+            const diff = (0, diff_1.diffLines)(normalizedLocal, normalizedRemote);
+            const hasDiff = diff.some(part => part.added || part.removed);
+            // 差分がある場合のみ処理・表示
+            if (hasDiff) {
+                // タイムスタンプ比較（ローカルファイルの実際の更新時刻も考慮）
+                const isRemoteNewer = remote.timestamp > local.timestamp;
+                const isLocalFileNewer = local.fileTimestamp > remote.timestamp;
+                const timeDiff = remote.timestamp - local.timestamp;
+                const fileDiff = local.fileTimestamp - remote.timestamp;
+                const timeDiffHours = Math.abs(timeDiff) / 3600;
+                const fileDiffHours = Math.abs(fileDiff) / 3600;
+                // ローカルファイルの方が新しい場合はリモートへマイグレーション提案
+                if (isLocalFileNewer) {
+                    console.log(`[${tableName}] ローカルが ${fileDiffHours.toFixed(1)}時間新しい - マイグレーション生成`);
+                }
+                else if (isRemoteNewer) {
+                    console.log(`[${tableName}] リモートが ${timeDiffHours.toFixed(1)}時間新しい - ローカル更新`);
+                }
+                else {
+                    console.log(`[${tableName}] 差分を検出 - 確認が必要`);
+                }
+                // 整形されたSQLで行単位の差分を表示
+                const formattedLocal = formatSQL(normalizedLocal);
+                const formattedRemote = formatSQL(normalizedRemote);
+                // ローカルが新しい場合は、ローカル→リモートの差分（マイグレーション用）
+                // リモートが新しい場合は、リモート→ローカルの差分（ローカル更新用）
+                const lineDiff = isLocalFileNewer
+                    ? (0, diff_1.diffLines)(formattedRemote, formattedLocal) // ローカル→リモート（マイグレーション用）
+                    : (0, diff_1.diffLines)(formattedLocal, formattedRemote); // リモート→ローカル（ローカル更新用）
+                // 前後のコンテキスト行数
+                const contextLines = 1;
+                let lineNumber = 0;
+                let outputLines = [];
+                lineDiff.forEach((part, index) => {
+                    const lines = part.value.split('\n').filter(line => line.trim() || index === lineDiff.length - 1);
+                    if (part.added) {
+                        // リモートから追加される行
+                        lines.forEach(line => {
+                            if (line.trim()) {
+                                outputLines.push(`\x1b[32m+ ${line}\x1b[0m`);
+                            }
+                        });
+                    }
+                    else if (part.removed) {
+                        // ローカルから削除される行
+                        lines.forEach(line => {
+                            if (line.trim()) {
+                                outputLines.push(`\x1b[31m- ${line}\x1b[0m`);
+                            }
+                        });
+                    }
+                    else {
+                        // 変更されていない行（コンテキスト）
+                        const unchangedLines = lines.filter(line => line.trim());
+                        // 差分の前後で適切にコンテキストを表示
+                        const hasChangeBefore = index > 0 && (lineDiff[index - 1].added || lineDiff[index - 1].removed);
+                        const hasChangeAfter = index < lineDiff.length - 1 && (lineDiff[index + 1].added || lineDiff[index + 1].removed);
+                        if (hasChangeBefore && hasChangeAfter) {
+                            // 前後に変更がある場合は全行表示
+                            unchangedLines.forEach(line => {
+                                outputLines.push(`  ${line}`);
+                            });
+                        }
+                        else if (hasChangeBefore) {
+                            // 前に変更がある場合は最初の数行のみ表示
+                            const showLines = Math.min(contextLines, unchangedLines.length);
+                            for (let i = 0; i < showLines; i++) {
+                                outputLines.push(`  ${unchangedLines[i]}`);
+                            }
+                            if (unchangedLines.length > contextLines) {
+                                outputLines.push(`  \x1b[36m...(${unchangedLines.length - contextLines} more lines)...\x1b[0m`);
+                            }
+                        }
+                        else if (hasChangeAfter) {
+                            // 後に変更がある場合は最後の数行のみ表示
+                            const showLines = Math.min(contextLines, unchangedLines.length);
+                            const startIndex = unchangedLines.length - showLines;
+                            // 冒頭のCREATE TABLE行は常に表示
+                            const hasCreateTable = unchangedLines.some(line => line.trim().toUpperCase().startsWith('CREATE TABLE'));
+                            if (hasCreateTable && startIndex > 0) {
+                                // CREATE TABLE行を探して表示
+                                const createTableIndex = unchangedLines.findIndex(line => line.trim().toUpperCase().startsWith('CREATE TABLE'));
+                                if (createTableIndex >= 0) {
+                                    outputLines.push(`  ${unchangedLines[createTableIndex]}`);
+                                    if (createTableIndex < startIndex - 1) {
+                                        outputLines.push(`  \x1b[36m...(${startIndex - createTableIndex - 1} lines)...\x1b[0m`);
+                                    }
+                                }
+                            }
+                            else if (startIndex > 0) {
+                                outputLines.push(`  \x1b[36m...(${startIndex} lines)...\x1b[0m`);
+                            }
+                            for (let i = startIndex; i < unchangedLines.length; i++) {
+                                outputLines.push(`  ${unchangedLines[i]}`);
+                            }
+                        }
+                        else if (unchangedLines.length <= contextLines * 2) {
+                            // 短い場合は全部表示
+                            unchangedLines.forEach(line => {
+                                outputLines.push(`  ${line}`);
+                            });
+                        }
+                        else {
+                            // 長い場合でも冒頭のCREATE TABLE行は表示
+                            const hasCreateTable = unchangedLines.some(line => line.trim().toUpperCase().startsWith('CREATE TABLE'));
+                            if (hasCreateTable) {
+                                const createTableIndex = unchangedLines.findIndex(line => line.trim().toUpperCase().startsWith('CREATE TABLE'));
+                                if (createTableIndex >= 0) {
+                                    outputLines.push(`  ${unchangedLines[createTableIndex]}`);
+                                    if (unchangedLines.length > 1) {
+                                        outputLines.push(`  \x1b[36m...(${unchangedLines.length - 1} unchanged lines)...\x1b[0m`);
+                                    }
+                                }
+                            }
+                            else {
+                                outputLines.push(`  \x1b[36m...(${unchangedLines.length} unchanged lines)...\x1b[0m`);
+                            }
+                        }
+                    }
+                });
+                outputLines.forEach(line => console.log(line));
+                if (isLocalFileNewer) {
+                    // マイグレーションファイルを生成（ローカル→リモートの差分）
+                    const migrationPath = await (0, generateMigration_1.generateMigrationFile)(tableName, normalizedRemote, // from（現在のリモート状態）
+                    normalizedLocal, // to（ローカルの目標状態）
+                    process.cwd());
+                }
+                else {
+                    // リモートが新しいかタイムスタンプが同じ場合：ローカルを更新
+                    const shouldAutoUpdate = isRemoteNewer && !isLocalFileNewer;
+                    const success = await (0, writeSchema_1.writeSchemaToFile)(remote.ddl, schemaDir, remote.timestamp, `${tableName}.sql`, tableName, shouldAutoUpdate);
+                    if (success) {
+                        console.log(`[${tableName}] ローカルファイルを更新しました`);
+                    }
+                }
+            }
+            // 差分がない場合は何も表示せず、何もしない
+        }
+    }
+}

package/dist/sync/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+// readline import removed - using raw mode instead
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wildcardMatch = wildcardMatch;
+exports.askUserConfirmation = askUserConfirmation;
+// ワイルドカードマッチング関数
+function wildcardMatch(str, pattern) {
+    return pattern === '*' || str.includes(pattern);
+}
+/**
+ * ユーザーに確認を求める（1文字入力で即座に判定）
+ */
+function askUserConfirmation(message, options) {
+    return new Promise((resolve) => {
+        const promptMessage = options?.message || '(y/N): ';
+        process.stdout.write(`${message} ${promptMessage}`);
+        // rawモードを有効にして1文字入力を受け取る
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        const onData = (key) => {
+            // クリーンアップ
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdin.removeListener('data', onData);
+            const lowerKey = key.toLowerCase();
+            if (lowerKey === 'y') {
+                console.log('y');
+                resolve(true);
+            }
+            else if (options?.allowAll && lowerKey === 'a') {
+                console.log('a');
+                resolve('all');
+            }
+            else if (lowerKey === 'n' || key === '\r' || key === '\n' || key === '\u0003') {
+                // n、Enter、または Ctrl+C
+                if (key === '\u0003') {
+                    console.log('\nOperation cancelled');
+                    process.exit(0);
+                }
+                console.log(lowerKey === 'n' ? 'n' : 'N');
+                resolve(false);
+            }
+            else {
+                // 無効なキー：デフォルトでfalse
+                console.log(`${key} (invalid input, treating as N)`);
+                resolve(false);
+            }
+        };
+        process.stdin.on('data', onData);
+    });
+}