relq 1.0.120 → 1.0.122

package/dist/cjs/cli/commands/diff.cjs

@@ -44,9 +44,69 @@ const env_loader_1 = require("../utils/env-loader.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 const snapshot_manager_1 = require("../utils/snapshot-manager.cjs");
 const schema_diff_1 = require("../utils/schema-diff.cjs");
-const schema_hash_1 = require("../utils/schema-hash.cjs");
 const migration_generator_1 = require("../utils/migration-generator.cjs");
 const relqignore_1 = require("../utils/relqignore.cjs");
+const schema_loader_1 = require("../utils/schema-loader.cjs");
+const ast_transformer_1 = require("../utils/ast-transformer.cjs");
+function applyIgnorePatterns(comparison, patterns) {
+    if (patterns.length === 0)
+        return;
+    const shouldIgnore = (name) => {
+        return patterns.some(pattern => {
+            if (pattern.includes('*')) {
+                const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                return regex.test(name);
+            }
+            return name === pattern;
+        });
+    };
+    comparison.added.tables = comparison.added.tables.filter(t => !shouldIgnore(t.name));
+    comparison.removed.tables = comparison.removed.tables.filter(t => !shouldIgnore(t.name));
+    comparison.modified.tables = comparison.modified.tables.filter(t => !shouldIgnore(t.name));
+    comparison.renamed.tables = comparison.renamed.tables.filter(t => !shouldIgnore(t.from) && !shouldIgnore(t.to));
+    comparison.added.columns = comparison.added.columns.filter(c => !shouldIgnore(c.table));
+    comparison.removed.columns = comparison.removed.columns.filter(c => !shouldIgnore(c.table));
+    comparison.modified.columns = comparison.modified.columns.filter(c => !shouldIgnore(c.table));
+    comparison.renamed.columns = comparison.renamed.columns.filter(c => !shouldIgnore(c.table));
+    comparison.added.indexes = comparison.added.indexes.filter(i => !shouldIgnore(i.table));
+    comparison.removed.indexes = comparison.removed.indexes.filter(i => !shouldIgnore(i.table));
+    comparison.modified.indexes = comparison.modified.indexes.filter(i => !shouldIgnore(i.table));
+    comparison.renamed.indexes = comparison.renamed.indexes.filter(i => !shouldIgnore(i.table));
+    comparison.added.constraints = comparison.added.constraints.filter(c => !shouldIgnore(c.table));
+    comparison.removed.constraints = comparison.removed.constraints.filter(c => !shouldIgnore(c.table));
+    comparison.modified.constraints = comparison.modified.constraints.filter(c => !shouldIgnore(c.table));
+    comparison.renamed.constraints = comparison.renamed.constraints.filter(c => !shouldIgnore(c.table));
+    comparison.added.triggers = comparison.added.triggers.filter(t => !shouldIgnore(t.table));
+    comparison.removed.triggers = comparison.removed.triggers.filter(t => !shouldIgnore(t.table));
+    comparison.modified.triggers = comparison.modified.triggers.filter(t => !shouldIgnore(t.oldTrigger.table));
+}
+function countComparison(comparison) {
+    return {
+        tables: { added: comparison.added.tables.length, removed: comparison.removed.tables.length, modified: comparison.modified.tables.length, renamed: comparison.renamed.tables.length },
+        columns: { added: comparison.added.columns.length, removed: comparison.removed.columns.length, modified: comparison.modified.columns.length, renamed: comparison.renamed.columns.length },
+        indexes: { added: comparison.added.indexes.length, removed: comparison.removed.indexes.length, modified: comparison.modified.indexes.length, renamed: comparison.renamed.indexes.length },
+        constraints: { added: comparison.added.constraints.length, removed: comparison.removed.constraints.length, modified: comparison.modified.constraints.length, renamed: comparison.renamed.constraints.length },
+        enums: { added: comparison.added.enums.length, removed: comparison.removed.enums.length, modified: comparison.modified.enums.length, renamed: comparison.renamed.enums.length },
+        sequences: { added: comparison.added.sequences.length, removed: comparison.removed.sequences.length, modified: comparison.modified.sequences.length, renamed: comparison.renamed.sequences.length },
+        functions: { added: comparison.added.functions.length, removed: comparison.removed.functions.length, modified: comparison.modified.functions.length, renamed: comparison.renamed.functions.length },
+        views: { added: comparison.added.views.length, removed: comparison.removed.views.length, modified: comparison.modified.views.length },
+        triggers: { added: comparison.added.triggers.length, removed: comparison.removed.triggers.length, modified: comparison.modified.triggers.length },
+        domains: { added: comparison.added.domains.length, removed: comparison.removed.domains.length, modified: comparison.modified.domains.length },
+        compositeTypes: { added: comparison.added.compositeTypes.length, removed: comparison.removed.compositeTypes.length, modified: comparison.modified.compositeTypes.length },
+        extensions: { added: comparison.added.extensions.length, removed: comparison.removed.extensions.length },
+    };
+}
+function renderCategoryLines(label, counts, pushMode) {
+    const { added, removed, modified = 0, renamed = 0 } = counts;
+    if (added > 0)
+        console.log(`   ${colors_1.colors.green('+')} ${added} ${label} ${pushMode ? 'to create' : 'in database only'}`);
+    if (removed > 0)
+        console.log(`   ${colors_1.colors.red('-')} ${removed} ${label} ${pushMode ? 'to drop' : 'in local only'}`);
+    if (modified > 0)
+        console.log(`   ${colors_1.colors.yellow('~')} ${modified} ${label} ${pushMode ? 'modified' : 'differ'}`);
+    if (renamed > 0)
+        console.log(`   ${colors_1.colors.cyan('→')} ${renamed} ${label} renamed`);
+}
 exports.default = (0, citty_1.defineCommand)({
     meta: { name: 'diff', description: 'Show schema differences' },
     args: {
@@ -63,95 +123,118 @@ exports.default = (0, citty_1.defineCommand)({
         const connection = config.connection;
         const includeFunctions = config.includeFunctions ?? false;
         const includeTriggers = config.includeTriggers ?? false;
+        const schemaPath = (0, config_loader_1.getSchemaPath)(config);
         const snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
-        const snapshot = (0, snapshot_manager_1.loadSnapshot)(snapshotPath);
-        if (!snapshot) {
-            console.log(`${colors_1.colors.yellow('No local snapshot.')}`);
-            console.log(`${colors_1.colors.muted('Run')} ${colors_1.colors.cyan('relq pull')} ${colors_1.colors.muted('first.')}`);
-            console.log('');
-            return;
-        }
         const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+        const rawPatterns = ignorePatterns.map(pat => pat.raw);
         const spin = p.spinner();
         try {
+            spin.start('Loading local schema file...');
+            const { ast: desiredAST } = await (0, schema_loader_1.loadSchemaFile)(schemaPath, projectRoot, config);
+            spin.stop('Schema file loaded');
             spin.start(`Connecting to ${(0, env_loader_1.getConnectionDescription)(connection)}...`);
             const dbSchema = await (0, dialect_introspect_1.dialectIntrospect)(config, {
                 includeFunctions,
                 includeTriggers,
             });
             spin.stop(`Connected — ${dbSchema.tables.length} tables in database`);
-            const localSchema = (0, snapshot_manager_1.snapshotToDatabaseSchema)(snapshot);
-            const rawPatterns = ignorePatterns.map(pat => pat.raw);
-            const pushDiff = (0, schema_diff_1.diffSchemas)((0, schema_hash_1.normalizeSchema)(dbSchema), (0, schema_hash_1.normalizeSchema)(localSchema));
-            const filteredPushDiff = (0, schema_diff_1.filterDiff)(pushDiff, rawPatterns);
-            const pullDiff = (0, schema_diff_1.diffSchemas)((0, schema_hash_1.normalizeSchema)(localSchema), (0, schema_hash_1.normalizeSchema)(dbSchema));
-            const filteredPullDiff = (0, schema_diff_1.filterDiff)(pullDiff, rawPatterns);
+            spin.start('Analyzing database schema...');
+            const dbParsedSchema = await (0, ast_transformer_1.introspectedToParsedSchema)(dbSchema);
+            const snapshot = (0, snapshot_manager_1.loadSnapshot)(snapshotPath);
+            if (snapshot && snapshot.tables) {
+                for (const dbTable of dbParsedSchema.tables) {
+                    const snapTable = snapshot.tables[dbTable.name];
+                    if (!snapTable)
+                        continue;
+                    if (snapTable.trackingId)
+                        dbTable.trackingId = snapTable.trackingId;
+                    for (const dbCol of dbTable.columns) {
+                        const snapCol = snapTable.columns?.[dbCol.name];
+                        if (snapCol?.trackingId)
+                            dbCol.trackingId = snapCol.trackingId;
+                    }
+                    for (const dbIdx of dbTable.indexes) {
+                        const snapIdx = snapTable.indexes?.[dbIdx.name];
+                        if (snapIdx?.trackingId)
+                            dbIdx.trackingId = snapIdx.trackingId;
+                    }
+                    for (const dbCon of dbTable.constraints) {
+                        const snapCon = snapTable.constraints?.[dbCon.name];
+                        if (snapCon?.trackingId)
+                            dbCon.trackingId = snapCon.trackingId;
+                    }
+                }
+            }
+            spin.stop('Schema analyzed');
+            const pushComparison = (0, schema_diff_1.compareSchemas)(dbParsedSchema, desiredAST);
+            applyIgnorePatterns(pushComparison, rawPatterns);
+            const pullComparison = (0, schema_diff_1.compareSchemas)(desiredAST, dbParsedSchema);
+            applyIgnorePatterns(pullComparison, rawPatterns);
             if (args.json) {
                 console.log(JSON.stringify({
-                    pushChanges: filteredPushDiff.summary,
-                    pullChanges: filteredPullDiff.summary,
-                    hasPushChanges: filteredPushDiff.hasChanges,
-                    hasPullChanges: filteredPullDiff.hasChanges,
+                    push: countComparison(pushComparison),
+                    pull: countComparison(pullComparison),
+                    hasPushChanges: pushComparison.hasChanges,
+                    hasPullChanges: pullComparison.hasChanges,
                 }, null, 2));
                 return;
             }
-            if (!filteredPushDiff.hasChanges && !filteredPullDiff.hasChanges) {
+            if (!pushComparison.hasChanges && !pullComparison.hasChanges) {
                 console.log('');
                 console.log(`${colors_1.colors.green('Local and database are in sync.')}`);
                 console.log('');
                 return;
             }
-            if (filteredPushDiff.hasChanges) {
-                const s = filteredPushDiff.summary;
+            if (pushComparison.hasChanges) {
+                const c = countComparison(pushComparison);
                 console.log('');
                 console.log(`${colors_1.colors.bold('Local changes')} ${colors_1.colors.muted('(push to apply)')}`);
                 console.log('');
-                if (s.tablesAdded > 0)
-                    console.log(`   ${colors_1.colors.green('+')} ${s.tablesAdded} table(s) to create`);
-                if (s.tablesRemoved > 0)
-                    console.log(`   ${colors_1.colors.red('-')} ${s.tablesRemoved} table(s) to drop`);
-                if (s.tablesModified > 0)
-                    console.log(`   ${colors_1.colors.yellow('~')} ${s.tablesModified} table(s) modified`);
-                if (s.columnsAdded > 0)
-                    console.log(`   ${colors_1.colors.green('+')} ${s.columnsAdded} column(s) to add`);
-                if (s.columnsRemoved > 0)
-                    console.log(`   ${colors_1.colors.red('-')} ${s.columnsRemoved} column(s) to drop`);
-                if (s.columnsModified > 0)
-                    console.log(`   ${colors_1.colors.yellow('~')} ${s.columnsModified} column(s) modified`);
+                renderCategoryLines('table(s)', c.tables, true);
+                renderCategoryLines('column(s)', c.columns, true);
+                renderCategoryLines('index(es)', c.indexes, true);
+                renderCategoryLines('constraint(s)', c.constraints, true);
+                renderCategoryLines('enum(s)', c.enums, true);
+                renderCategoryLines('sequence(s)', c.sequences, true);
+                renderCategoryLines('function(s)', c.functions, true);
+                renderCategoryLines('view(s)', c.views, true);
+                renderCategoryLines('trigger(s)', c.triggers, true);
+                renderCategoryLines('domain(s)', c.domains, true);
+                renderCategoryLines('composite type(s)', c.compositeTypes, true);
+                renderCategoryLines('extension(s)', c.extensions, true);
             }
-            if (filteredPullDiff.hasChanges) {
-                const s = filteredPullDiff.summary;
+            if (pullComparison.hasChanges) {
+                const c = countComparison(pullComparison);
                 console.log('');
                 console.log(`${colors_1.colors.bold('Database drift')} ${colors_1.colors.muted('(pull to sync)')}`);
                 console.log('');
-                if (s.tablesAdded > 0)
-                    console.log(`   ${colors_1.colors.green('+')} ${s.tablesAdded} table(s) in database only`);
-                if (s.tablesRemoved > 0)
-                    console.log(`   ${colors_1.colors.red('-')} ${s.tablesRemoved} table(s) in local only`);
-                if (s.tablesModified > 0)
-                    console.log(`   ${colors_1.colors.yellow('~')} ${s.tablesModified} table(s) differ`);
-                if (s.columnsAdded > 0)
-                    console.log(`   ${colors_1.colors.green('+')} ${s.columnsAdded} column(s) in database only`);
-                if (s.columnsRemoved > 0)
-                    console.log(`   ${colors_1.colors.red('-')} ${s.columnsRemoved} column(s) in local only`);
-                if (s.columnsModified > 0)
-                    console.log(`   ${colors_1.colors.yellow('~')} ${s.columnsModified} column(s) differ`);
+                renderCategoryLines('table(s)', c.tables, false);
+                renderCategoryLines('column(s)', c.columns, false);
+                renderCategoryLines('index(es)', c.indexes, false);
+                renderCategoryLines('constraint(s)', c.constraints, false);
+                renderCategoryLines('enum(s)', c.enums, false);
+                renderCategoryLines('sequence(s)', c.sequences, false);
+                renderCategoryLines('function(s)', c.functions, false);
+                renderCategoryLines('view(s)', c.views, false);
+                renderCategoryLines('trigger(s)', c.triggers, false);
+                renderCategoryLines('domain(s)', c.domains, false);
+                renderCategoryLines('composite type(s)', c.compositeTypes, false);
+                renderCategoryLines('extension(s)', c.extensions, false);
             }
-            if (args.sql && filteredPushDiff.hasChanges) {
+            if (args.sql && pushComparison.hasChanges) {
                 console.log('');
                 console.log(`${colors_1.colors.bold('SQL Preview')} ${colors_1.colors.muted('(what push would execute)')}`);
                 console.log('');
-                const migration = (0, migration_generator_1.generateMigrationFile)(filteredPushDiff, 'diff-preview', {
-                    includeDown: false,
-                    includeComments: false,
-                });
-                if (migration.content.trim()) {
-                    const statements = migration.content.split(';').filter(s => s.trim());
-                    for (const stmt of statements.slice(0, 20)) {
-                        console.log(`   ${colors_1.colors.cyan(stmt.trim())};`);
+                const migration = (0, migration_generator_1.generateMigrationFromComparison)(pushComparison);
+                const formatted = (0, migration_generator_1.formatMigrationStatements)(migration.up);
+                if (formatted.length > 0) {
+                    for (const line of formatted.slice(0, 30)) {
+                        console.log(`   ${line.startsWith('--') ? colors_1.colors.muted(line) : colors_1.colors.cyan(line)}`);
                     }
-                    if (statements.length > 20) {
-                        console.log(`   ${colors_1.colors.muted(`... and ${statements.length - 20} more statements`)}`);
+                    const stmtCount = formatted.filter(l => l.trim() && !l.trim().startsWith('--')).length;
+                    const totalStmts = migration.up.length;
+                    if (totalStmts > 20) {
+                        console.log(`   ${colors_1.colors.muted(`... and ${totalStmts - 20} more statements`)}`);
                     }
                 }
                 else {
@@ -159,10 +242,10 @@ exports.default = (0, citty_1.defineCommand)({
                 }
             }
             console.log('');
-            if (filteredPushDiff.hasChanges) {
+            if (pushComparison.hasChanges) {
                 console.log(`${colors_1.colors.muted('Run')} ${colors_1.colors.cyan('relq push')} ${colors_1.colors.muted('to apply local changes to database.')}`);
             }
-            if (filteredPullDiff.hasChanges) {
+            if (pullComparison.hasChanges) {
                 console.log(`${colors_1.colors.muted('Run')} ${colors_1.colors.cyan('relq pull')} ${colors_1.colors.muted('to sync local with database.')}`);
             }
             console.log('');

package/dist/cjs/cli/commands/fix.cjs

@@ -0,0 +1,298 @@
+"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 });
+const citty_1 = require("citty");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const context_1 = require("../utils/context.cjs");
+const colors_1 = require("../utils/colors.cjs");
+const ui_1 = require("../utils/ui.cjs");
+const config_loader_1 = require("../utils/config-loader.cjs");
+const schema_loader_1 = require("../utils/schema-loader.cjs");
+const tracking_id_validator_1 = require("../utils/tracking-id-validator.cjs");
+const source_id_validator_1 = require("../utils/source-id-validator.cjs");
+const ast_codegen_1 = require("../utils/ast-codegen.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+const schema_surgeon_1 = require("../utils/schema-surgeon.cjs");
+function clearDuplicateTrackingIds(schema) {
+    let fixCount = 0;
+    const tableIds = new Map();
+    for (const table of schema.tables) {
+        if (table.partitionOf)
+            continue;
+        if (table.trackingId) {
+            if (tableIds.has(table.trackingId)) {
+                table.trackingId = undefined;
+                fixCount++;
+            }
+            else {
+                tableIds.set(table.trackingId, true);
+            }
+        }
+    }
+    for (const table of schema.tables) {
+        if (table.partitionOf)
+            continue;
+        const colIds = new Map();
+        for (const col of table.columns) {
+            if (col.trackingId) {
+                if (colIds.has(col.trackingId)) {
+                    col.trackingId = undefined;
+                    fixCount++;
+                }
+                else {
+                    colIds.set(col.trackingId, true);
+                }
+            }
+        }
+        const idxIds = new Map();
+        for (const idx of table.indexes) {
+            if (idx.trackingId) {
+                if (idxIds.has(idx.trackingId)) {
+                    idx.trackingId = undefined;
+                    fixCount++;
+                }
+                else {
+                    idxIds.set(idx.trackingId, true);
+                }
+            }
+        }
+        const conIds = new Map();
+        for (const con of table.constraints) {
+            if (con.trackingId) {
+                if (colIds.has(con.trackingId))
+                    continue;
+                if (conIds.has(con.trackingId)) {
+                    con.trackingId = undefined;
+                    fixCount++;
+                }
+                else {
+                    conIds.set(con.trackingId, true);
+                }
+            }
+        }
+    }
+    return fixCount;
+}
+function buildExportMap(schemaModule) {
+    const map = new Map();
+    for (const [key, value] of Object.entries(schemaModule)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        if (value.$name && typeof value.$name === 'string') {
+            map.set(value.$name, key);
+        }
+        else if (value.$enumName && typeof value.$enumName === 'string') {
+            map.set(value.$enumName, key);
+        }
+        else if (value.$domainName && typeof value.$domainName === 'string') {
+            map.set(value.$domainName, key);
+        }
+        else if (value.$sequenceName && typeof value.$sequenceName === 'string') {
+            map.set(value.$sequenceName, key);
+        }
+        else if (value.$functionName && typeof value.$functionName === 'string') {
+            map.set(value.$functionName, key);
+        }
+        else if (value.$triggerName && typeof value.$triggerName === 'string') {
+            map.set(value.$triggerName, key);
+        }
+        else if (value.$viewName && typeof value.$viewName === 'string') {
+            map.set(value.$viewName, key);
+        }
+    }
+    return map;
+}
+exports.default = (0, citty_1.defineCommand)({
+    meta: { name: 'fix', description: 'Auto-repair tracking ID issues in schema' },
+    args: {
+        schema: { type: 'positional', description: 'Schema file path (optional)', required: false },
+        dryRun: { type: 'boolean', alias: 'dry-run', description: 'Show what would be fixed without writing' },
+    },
+    async run({ args }) {
+        const { config, projectRoot } = await (0, context_1.buildContext)({ requireConfig: true });
+        if (!config)
+            return (0, ui_1.fatal)('No relq.config.ts found. Run `relq init` first.');
+        console.log('');
+        let schemaPath;
+        if (args.schema) {
+            schemaPath = path.resolve(projectRoot, args.schema);
+        }
+        else {
+            schemaPath = path.resolve(projectRoot, (0, config_loader_1.getSchemaPath)(config));
+        }
+        const relativePath = path.relative(process.cwd(), schemaPath);
+        if (!fs.existsSync(schemaPath)) {
+            return (0, ui_1.fatal)(`Schema file not found: ${relativePath}`);
+        }
+        console.log(`  Scanning ${colors_1.colors.cyan(relativePath)}...`);
+        const rawContent = fs.readFileSync(schemaPath, 'utf-8');
+        const sourceIssues = (0, source_id_validator_1.validateSourceTrackingIds)(schemaPath, rawContent);
+        let result;
+        try {
+            result = await (0, schema_loader_1.loadSchemaFile)(schemaPath, projectRoot, config);
+        }
+        catch (err) {
+            return (0, ui_1.fatal)(`Failed to load schema: ${err.message}`);
+        }
+        const { ast: parsedSchema } = result;
+        const runtimeIssues = (0, tracking_id_validator_1.validateTrackingIds)(parsedSchema);
+        const runtimeDuplicates = runtimeIssues.filter(i => i.kind === 'duplicate');
+        const runtimeMissing = runtimeIssues.filter(i => i.kind === 'missing');
+        const sourceLocations = new Set(sourceIssues.map(i => i.location));
+        const extraRuntimeMissing = runtimeMissing.filter(i => !sourceLocations.has(i.location));
+        const issuesBefore = [...sourceIssues, ...extraRuntimeMissing, ...runtimeDuplicates];
+        if (issuesBefore.length === 0) {
+            console.log('');
+            console.log(`  ${colors_1.colors.green('✔')}  ${colors_1.colors.bold('No issues found')} — schema tracking IDs are clean.`);
+            console.log('');
+            return;
+        }
+        const missingIssues = issuesBefore.filter(i => i.kind === 'missing');
+        const duplicateIssues = issuesBefore.filter(i => i.kind === 'duplicate');
+        if (args.dryRun) {
+            console.log('');
+            console.log((0, tracking_id_validator_1.formatTrackingIdIssues)(issuesBefore));
+            console.log('');
+            console.log(colors_1.colors.dim('  Dry run — no changes written.'));
+            console.log('');
+            return;
+        }
+        for (const issue of sourceIssues) {
+            if (issue.kind !== 'missing')
+                continue;
+            const parts = issue.location.split('.');
+            const tableName = parts[0];
+            const entityName = parts.slice(1).join('.');
+            const table = parsedSchema.tables.find(t => t.name === tableName);
+            if (!table)
+                continue;
+            if (issue.entity === 'index' && entityName) {
+                const idx = table.indexes.find(i => i.name === entityName);
+                if (idx)
+                    idx.trackingId = undefined;
+            }
+            else if (issue.entity === 'constraint' && entityName) {
+                const con = table.constraints.find(c => c.name === entityName);
+                if (con)
+                    con.trackingId = undefined;
+            }
+        }
+        const dupsFixed = clearDuplicateTrackingIds(parsedSchema);
+        (0, ast_codegen_1.assignTrackingIds)(parsedSchema);
+        const { createJiti } = await Promise.resolve().then(() => __importStar(require('jiti')));
+        const jiti = createJiti(projectRoot, { interopDefault: true });
+        const schemaModule = await jiti.import(schemaPath);
+        const exportMap = buildExportMap(schemaModule);
+        const tableIssues = issuesBefore.filter(i => i.entity === 'table' || i.entity === 'column' || i.entity === 'index' || i.entity === 'constraint');
+        const edits = (0, schema_surgeon_1.computeTrackingIdEdits)(schemaPath, rawContent, tableIssues, parsedSchema, exportMap);
+        const enumNames = new Set(parsedSchema.enums.map(e => e.name));
+        const domainNames = new Set(parsedSchema.domains.map(d => d.name));
+        const seqNames = new Set(parsedSchema.sequences.map(s => s.name));
+        for (const issue of issuesBefore) {
+            if (issue.entity !== 'table')
+                continue;
+            const name = issue.location;
+            if (enumNames.has(name)) {
+                const enumEdits = (0, schema_surgeon_1.computeTopLevelEdits)(schemaPath, rawContent, 'enum', parsedSchema.enums, exportMap, [issue]);
+                edits.push(...enumEdits);
+            }
+            else if (domainNames.has(name)) {
+                const domainEdits = (0, schema_surgeon_1.computeTopLevelEdits)(schemaPath, rawContent, 'domain', parsedSchema.domains, exportMap, [issue]);
+                edits.push(...domainEdits);
+            }
+            else if (seqNames.has(name)) {
+                const seqEdits = (0, schema_surgeon_1.computeTopLevelEdits)(schemaPath, rawContent, 'sequence', parsedSchema.sequences, exportMap, [issue]);
+                edits.push(...seqEdits);
+            }
+        }
+        if (edits.length === 0) {
+            console.log('');
+            console.log(colors_1.colors.dim('  Could not locate all entities in source — falling back to regeneration.'));
+            const { generateTypeScriptFromAST } = await Promise.resolve().then(() => __importStar(require("../utils/ast-codegen.cjs")));
+            const { detectDialect, getBuilderImportPath } = await Promise.resolve().then(() => __importStar(require("../utils/dialect-router.cjs")));
+            const dialect = detectDialect(config);
+            const builderImportPath = getBuilderImportPath(dialect);
+            const schemaBaseName = path.basename(schemaPath, '.ts');
+            const typesImportPath = `./${schemaBaseName}.types`;
+            const typescript = generateTypeScriptFromAST(parsedSchema, {
+                camelCase: config.generate?.camelCase ?? true,
+                importPath: builderImportPath,
+                includeFunctions: false,
+                includeTriggers: false,
+                columnTypeMap: {},
+                typesImportPath,
+            });
+            fs.writeFileSync(schemaPath, typescript, 'utf-8');
+            const fileHash = (0, repo_manager_1.hashFileContent)(typescript);
+            (0, repo_manager_1.saveFileHash)(fileHash, projectRoot);
+        }
+        else {
+            const fixed = (0, schema_surgeon_1.applyEdits)(rawContent, edits);
+            fs.writeFileSync(schemaPath, fixed, 'utf-8');
+            const fileHash = (0, repo_manager_1.hashFileContent)(fixed);
+            (0, repo_manager_1.saveFileHash)(fileHash, projectRoot);
+        }
+        const fixedContent = fs.readFileSync(schemaPath, 'utf-8');
+        const sourceIssuesAfter = (0, source_id_validator_1.validateSourceTrackingIds)(schemaPath, fixedContent);
+        const reloaded = await (0, schema_loader_1.loadSchemaFile)(schemaPath, projectRoot, config);
+        const runtimeIssuesAfter = (0, tracking_id_validator_1.validateTrackingIds)(reloaded.ast);
+        const remainingErrors = [
+            ...sourceIssuesAfter,
+            ...runtimeIssuesAfter.filter(i => i.severity === 'error'),
+        ];
+        if (remainingErrors.length > 0) {
+            console.log('');
+            console.log((0, tracking_id_validator_1.formatTrackingIdIssues)(remainingErrors));
+            console.log('');
+            return (0, ui_1.fatal)('Some issues could not be auto-fixed.');
+        }
+        console.log('');
+        console.log(`  ${colors_1.colors.green('✔')}  ${colors_1.colors.bold('All issues fixed')}`);
+        console.log(colors_1.colors.dim('  ───────────────────────────────────'));
+        if (edits.length > 0) {
+            console.log(`    ${colors_1.colors.green('●')} ${edits.length} surgical edit(s) applied`);
+        }
+        if (missingIssues.length > 0) {
+            console.log(`    ${colors_1.colors.green('+')} ${missingIssues.length} missing ID(s) generated`);
+        }
+        if (dupsFixed > 0) {
+            console.log(`    ${colors_1.colors.green('~')} ${dupsFixed} duplicate ID(s) regenerated`);
+        }
+        console.log('');
+        console.log(`  Updated ${colors_1.colors.cyan(relativePath)}`);
+        console.log('');
+    },
+});