relq 1.0.1 → 1.0.3

package/dist/cjs/cli/commands/add.cjs

@@ -1,55 +1,460 @@
 "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.addCommand = addCommand;
 exports.getRelatedChanges = getRelatedChanges;
+const fs = __importStar(require("fs"));
 const spinner_1 = require("../utils/spinner.cjs");
+const relqignore_1 = require("../utils/relqignore.cjs");
+const config_1 = require("../../config/config.cjs");
+const path = __importStar(require("path"));
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 const change_tracker_1 = require("../utils/change-tracker.cjs");
+const schema_comparator_1 = require("../utils/schema-comparator.cjs");
+function parseSchemaFileForComparison(schemaPath) {
+    if (!fs.existsSync(schemaPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(schemaPath, 'utf-8');
+    const tables = [];
+    const tableStartRegex = /defineTable\s*\(\s*['"]([^'"]+)['"],\s*\{/g;
+    let tableStartMatch;
+    while ((tableStartMatch = tableStartRegex.exec(content)) !== null) {
+        const tableName = tableStartMatch[1];
+        const startIdx = tableStartMatch.index + tableStartMatch[0].length;
+        let braceCount = 1;
+        let endIdx = startIdx;
+        while (braceCount > 0 && endIdx < content.length) {
+            const char = content[endIdx];
+            if (char === '{')
+                braceCount++;
+            else if (char === '}')
+                braceCount--;
+            endIdx++;
+        }
+        const columnsBlock = content.substring(startIdx, endIdx - 1);
+        let optionsBlock = '';
+        const afterColumns = content.substring(endIdx);
+        const optionsMatch = afterColumns.match(/^\s*,\s*\{/);
+        if (optionsMatch) {
+            const optStart = endIdx + optionsMatch[0].length;
+            braceCount = 1;
+            let optEnd = optStart;
+            while (braceCount > 0 && optEnd < content.length) {
+                const char = content[optEnd];
+                if (char === '{')
+                    braceCount++;
+                else if (char === '}')
+                    braceCount--;
+                optEnd++;
+            }
+            optionsBlock = content.substring(optStart, optEnd - 1);
+        }
+        const columns = [];
+        const constraints = [];
+        const tsToDbNameMap = new Map();
+        const lines = columnsBlock.split('\n');
+        let currentColDef = '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*'))
+                continue;
+            currentColDef += ' ' + trimmed;
+            if (trimmed.endsWith(',') || trimmed.endsWith(')')) {
+                const colDef = currentColDef.trim();
+                currentColDef = '';
+                const typePattern = 'varchar|text|uuid|integer|bigint|boolean|timestamp|date|jsonb|json|numeric|serial|bigserial|smallserial|tsvector|smallint|real|doublePrecision|char|inet|cidr|macaddr|macaddr8|interval|time|point|line|lseg|box|path|polygon|circle|bytea|bit|varbit|money|xml|oid';
+                const colMatch = colDef.match(new RegExp(`^(\\w+):\\s*(${typePattern})`));
+                if (!colMatch)
+                    continue;
+                const tsName = colMatch[1];
+                const type = colMatch[2];
+                const explicitNameMatch = colDef.match(new RegExp(`${type}\\s*\\(['\"]([^'"]+)['\"]`));
+                const dbColName = explicitNameMatch ? explicitNameMatch[1] : tsName;
+                tsToDbNameMap.set(tsName, dbColName);
+                let defaultValue = null;
+                const isJsonbColumn = type === 'jsonb' || type === 'json';
+                const isArrayColumn = colDef.includes('.array()');
+                const bigintMatch = colDef.match(/\.default\(\s*BigInt\(\s*(-?\d+)\s*\)\s*\)/);
+                if (bigintMatch) {
+                    defaultValue = bigintMatch[1];
+                }
+                const funcDefaultMatch = !defaultValue && colDef.match(/\.default\(\s*(genRandomUuid|now|currentDate|currentTimestamp|emptyArray|emptyObject)\s*\(\s*\)\s*\)/);
+                if (funcDefaultMatch) {
+                    const funcName = funcDefaultMatch[1];
+                    if (funcName === 'emptyArray') {
+                        defaultValue = isJsonbColumn ? "'[]'::jsonb" : "'{}'::text[]";
+                    }
+                    else if (funcName === 'emptyObject') {
+                        defaultValue = "'{}'::jsonb";
+                    }
+                    else {
+                        const funcToSql = {
+                            'genRandomUuid': 'gen_random_uuid()',
+                            'now': 'now()',
+                            'currentDate': 'CURRENT_DATE',
+                            'currentTimestamp': 'CURRENT_TIMESTAMP',
+                        };
+                        defaultValue = funcToSql[funcName] || `${funcName}()`;
+                    }
+                }
+                else {
+                    const strDefaultMatch = colDef.match(/\.default\(\s*(['"])([^'"]*)\1\s*\)/);
+                    if (strDefaultMatch) {
+                        defaultValue = strDefaultMatch[2];
+                    }
+                    else {
+                        const boolDefaultMatch = colDef.match(/\.default\(\s*(true|false)\s*\)/);
+                        if (boolDefaultMatch) {
+                            defaultValue = boolDefaultMatch[1];
+                        }
+                        else {
+                            const numDefaultMatch = colDef.match(/\.default\(\s*(-?\d+(?:\.\d+)?)\s*\)/);
+                            if (numDefaultMatch) {
+                                defaultValue = numDefaultMatch[1];
+                            }
+                            else {
+                                const jsonObjMatch = colDef.match(/\.default\(\s*(\{[^}]+\})\s*\)/);
+                                if (jsonObjMatch) {
+                                    defaultValue = `'${jsonObjMatch[1]}'::jsonb`;
+                                }
+                                else {
+                                    const arrayLiteralMatch = colDef.match(/\.default\(\s*(\[[^\]]+\])\s*\)/);
+                                    if (arrayLiteralMatch) {
+                                        const arrayStr = arrayLiteralMatch[1];
+                                        defaultValue = `'${arrayStr}'::jsonb`;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                if (colDef.includes('.check(')) {
+                    const checkValuesMatch = colDef.match(/\.check\(([^)]+)\)/);
+                    if (checkValuesMatch) {
+                        const valuesStr = checkValuesMatch[1];
+                        const values = valuesStr.match(/['"]([^'"]+)['"]/g)?.map(v => v.replace(/['"]/g, '')) || [];
+                        if (values.length > 0) {
+                            const constraintName = `${tableName}_${dbColName}_check`;
+                            constraints.push({
+                                name: constraintName,
+                                type: 'CHECK',
+                                columns: [dbColName],
+                                definition: '',
+                            });
+                        }
+                    }
+                }
+                let comment = null;
+                const commentMatch = colDef.match(/\.comment\(\s*(['"])([^'"]*)\1\s*\)/);
+                if (commentMatch) {
+                    comment = commentMatch[2];
+                }
+                if (colDef.includes('.identity()')) {
+                    defaultValue = defaultValue || 'GENERATED BY DEFAULT AS IDENTITY';
+                }
+                const isArray = colDef.includes('.array()');
+                columns.push({
+                    name: dbColName,
+                    dataType: isArray ? `${type}[]` : type,
+                    isNullable: !colDef.includes('.notNull()') && !colDef.includes('.primaryKey()'),
+                    defaultValue,
+                    isPrimaryKey: colDef.includes('.primaryKey()'),
+                    isUnique: colDef.includes('.unique()'),
+                    maxLength: null,
+                    precision: null,
+                    scale: null,
+                    references: null,
+                    comment,
+                });
+            }
+        }
+        const indexes = [];
+        const indexRegex = /index\s*\(\s*['"]([^'"]+)['"]\s*\)\.on\(([^)]+)\)/g;
+        let idxMatch;
+        while ((idxMatch = indexRegex.exec(optionsBlock)) !== null) {
+            const indexName = idxMatch[1];
+            const indexCols = idxMatch[2].split(',').map(c => {
+                const tsColName = c.trim().replace(/table\.\s*/, '');
+                return tsToDbNameMap.get(tsColName) || tsColName;
+            });
+            const isUnique = optionsBlock.includes(`index('${indexName}')`) &&
+                optionsBlock.substring(optionsBlock.indexOf(`index('${indexName}')`)).split('\n')[0].includes('.unique()');
+            indexes.push({
+                name: indexName,
+                columns: indexCols,
+                isUnique: isUnique,
+                isPrimary: false,
+                type: 'btree',
+                definition: '',
+                whereClause: null,
+                expression: null,
+            });
+        }
+        const checkRegexLegacy = /check\s*\(\s*['"]([^'"]+)['"]\s*,\s*sql`([^`]+)`\s*\)/g;
+        let tableCheckMatch;
+        while ((tableCheckMatch = checkRegexLegacy.exec(optionsBlock)) !== null) {
+            constraints.push({
+                name: tableCheckMatch[1],
+                type: 'CHECK',
+                columns: [],
+                definition: tableCheckMatch[2].trim(),
+            });
+        }
+        const checkRegexNew = /check\.constraint\s*\(\s*['"]([^'"]+)['"]/g;
+        let newCheckMatch;
+        while ((newCheckMatch = checkRegexNew.exec(optionsBlock)) !== null) {
+            const constraintName = newCheckMatch[1];
+            if (!constraints.some(c => c.name === constraintName)) {
+                constraints.push({
+                    name: constraintName,
+                    type: 'CHECK',
+                    columns: [],
+                    definition: '',
+                });
+            }
+        }
+        const checkConstraintsBlockMatch = optionsBlock.match(/checkConstraints:\s*\([^)]+\)\s*=>\s*\[([^\]]+)\]/s);
+        if (checkConstraintsBlockMatch) {
+            const checkBlock = checkConstraintsBlockMatch[1];
+            const constraintNameMatches = checkBlock.matchAll(/check\.constraint\s*\(\s*['"]([^'"]+)['"]/g);
+            for (const match of constraintNameMatches) {
+                const constraintName = match[1];
+                if (!constraints.some(c => c.name === constraintName)) {
+                    constraints.push({
+                        name: constraintName,
+                        type: 'CHECK',
+                        columns: [],
+                        definition: '',
+                    });
+                }
+            }
+        }
+        let partitionType;
+        let partitionKey;
+        const partitionByMatch = optionsBlock.match(/partitionBy:\s*\([^)]+\)\s*=>\s*\w+\.(list|range|hash)\(([^)]+)\)/i);
+        if (partitionByMatch) {
+            partitionType = partitionByMatch[1].toUpperCase();
+            const tsPartitionKey = partitionByMatch[2].replace(/table\./, '').trim();
+            const dbPartitionKey = tsToDbNameMap.get(tsPartitionKey) || tsPartitionKey;
+            partitionKey = [dbPartitionKey];
+        }
+        tables.push({
+            name: tableName,
+            schema: 'public',
+            columns,
+            indexes,
+            constraints,
+            rowCount: 0,
+            isPartitioned: !!partitionType,
+            partitionType,
+            partitionKey,
+        });
+    }
+    const enums = [];
+    const enumRegex = /defineEnum\s*\(\s*['"]([^'"]+)['"]\s*,\s*\[([^\]]+)\]/g;
+    let enumMatch;
+    while ((enumMatch = enumRegex.exec(content)) !== null) {
+        const enumName = enumMatch[1];
+        const valuesStr = enumMatch[2];
+        const values = valuesStr.match(/['"]([^'"]+)['"]/g)?.map(v => v.replace(/['"]/g, '')) || [];
+        enums.push({ name: enumName, values });
+    }
+    const extensions = [];
+    const singleExtMatch = content.match(/pgExtensions\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+    if (singleExtMatch) {
+        extensions.push(singleExtMatch[1]);
+    }
+    else {
+        const arrayExtMatch = content.match(/pgExtensions\s*\(\s*\[([^\]]+)\]/);
+        if (arrayExtMatch) {
+            const extList = arrayExtMatch[1].match(/['"]([^'"]+)['"]/g);
+            if (extList) {
+                extList.forEach(e => extensions.push(e.replace(/['"]/g, '')));
+            }
+        }
+    }
+    return {
+        tables,
+        enums,
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        collations: [],
+        functions: [],
+        triggers: [],
+        policies: [],
+        partitions: [],
+        foreignServers: [],
+        foreignTables: [],
+        extensions,
+    };
+}
+function snapshotToDatabaseSchema(snapshot) {
+    const tables = (snapshot.tables || []).map(t => ({
+        name: t.name,
+        schema: t.schema || 'public',
+        columns: (t.columns || []).map(c => ({
+            name: c.name,
+            dataType: c.type || 'text',
+            isNullable: c.nullable !== false,
+            defaultValue: c.default || null,
+            isPrimaryKey: c.primaryKey || false,
+            isUnique: c.unique || false,
+            maxLength: null,
+            precision: null,
+            scale: null,
+            references: null,
+            comment: c.comment || null,
+        })),
+        indexes: (t.indexes || []).map(i => ({
+            name: i.name,
+            columns: Array.isArray(i.columns) ? i.columns : [i.columns],
+            isUnique: i.unique || false,
+            isPrimary: false,
+            type: i.type || 'btree',
+            definition: i.definition || '',
+            whereClause: i.whereClause || null,
+            expression: null,
+        })),
+        constraints: (t.constraints || []).map(c => ({
+            name: c.name,
+            type: c.type,
+            columns: c.columns || [],
+            definition: c.definition || '',
+        })),
+        rowCount: 0,
+        isPartitioned: t.isPartitioned || false,
+        partitionType: t.partitionType,
+        partitionKey: t.partitionKey ? (Array.isArray(t.partitionKey) ? t.partitionKey : [t.partitionKey]) : undefined,
+    }));
+    return {
+        tables,
+        enums: (snapshot.enums || []).map(e => ({ name: e.name, values: e.values })),
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        collations: [],
+        functions: [],
+        triggers: [],
+        policies: [],
+        partitions: [],
+        foreignServers: [],
+        foreignTables: [],
+        extensions: (snapshot.extensions || []).map(e => typeof e === 'string' ? e : e.name),
+    };
+}
 async function addCommand(context) {
-    const { args } = context;
-    const projectRoot = process.cwd();
+    const { args, projectRoot } = context;
     console.log('');
     if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
-        console.log(`${spinner_1.colors.red('error:')} relq not initialized`);
-        console.log('');
-        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('first.')}`);
-        return;
+        (0, spinner_1.fatal)('not a relq repository (or any parent directories): .relq', `Run ${spinner_1.colors.cyan('relq init')} to initialize.`);
+    }
+    const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+    const config = await (0, config_1.loadConfig)();
+    const schemaPathRaw = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
+    const schemaPath = path.resolve(projectRoot, schemaPathRaw);
+    const fileChange = (0, repo_manager_1.detectFileChanges)(schemaPath, projectRoot);
+    if (fileChange) {
+        const currentSchema = parseSchemaFileForComparison(schemaPath);
+        const snapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+        if (currentSchema && snapshot) {
+            const snapshotAsDbSchema = snapshotToDatabaseSchema(snapshot);
+            const schemaChanges = (0, schema_comparator_1.compareSchemas)(snapshotAsDbSchema, currentSchema);
+            if (schemaChanges.length > 0) {
+                (0, repo_manager_1.clearUnstagedChanges)(projectRoot);
+                (0, repo_manager_1.addUnstagedChanges)(schemaChanges, projectRoot);
+            }
+            else {
+                const existingUnstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+                const hasFileChange = existingUnstaged.some(c => c.objectType === 'SCHEMA_FILE');
+                if (!hasFileChange) {
+                    (0, repo_manager_1.addUnstagedChanges)([fileChange], projectRoot);
+                }
+            }
+        }
     }
-    const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    const allUnstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
     const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
+    const unstaged = allUnstaged.filter(change => {
+        const objectType = change.objectType;
+        const result = (0, relqignore_1.isIgnored)(objectType, change.objectName, change.parentName || null, ignorePatterns);
+        if (result.ignored) {
+            return false;
+        }
+        if (['FUNCTION', 'PROCEDURE'].includes(change.objectType) && !config.includeFunctions) {
+            return false;
+        }
+        if (change.objectType === 'TRIGGER' && !config.includeTriggers) {
+            return false;
+        }
+        if (['VIEW', 'MATERIALIZED_VIEW'].includes(change.objectType) && !config.includeViews) {
+            return false;
+        }
+        if (change.objectType === 'FOREIGN_TABLE' && !config.includeFDW) {
+            return false;
+        }
+        return true;
+    });
+    const filteredCount = allUnstaged.length - unstaged.length;
     if (unstaged.length === 0) {
         if (staged.length > 0) {
-            console.log(`${spinner_1.colors.green('✓')} All changes are already staged`);
+            console.log('All changes are already staged');
             console.log(`${spinner_1.colors.muted(`${staged.length} change(s) ready to commit`)}`);
             console.log('');
-            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "message"')} ${spinner_1.colors.muted('to commit.')}`);
+            console.log(`hint: run 'relq commit -m "message"' to commit`);
+        }
+        else if (filteredCount > 0) {
+            console.log('No stageable changes');
+            console.log(`${spinner_1.colors.muted(`${filteredCount} change(s) filtered by .relqignore or config`)}`);
         }
         else {
-            console.log(`${spinner_1.colors.green('✓')} No changes to stage`);
-            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq pull')} ${spinner_1.colors.muted('or')} ${spinner_1.colors.cyan('relq import')} ${spinner_1.colors.muted('to detect changes.')}`);
+            console.log('No changes to stage');
+            console.log(`hint: run 'relq pull' or 'relq import' to detect changes`);
         }
         console.log('');
         return;
     }
     const patterns = args.length > 0 ? args : ['.'];
-    const addAll = patterns.includes('.') || patterns.includes('*');
-    console.log(`${spinner_1.colors.cyan('Unstaged changes:')} ${unstaged.length}`);
-    console.log('');
-    for (const change of unstaged) {
-        const display = (0, change_tracker_1.getChangeDisplayName)(change);
-        const color = change.type === 'CREATE' ? spinner_1.colors.green :
-            change.type === 'DROP' ? spinner_1.colors.red :
-                spinner_1.colors.yellow;
-        console.log(`   ${color(display)}`);
-    }
-    console.log('');
     const stagedNow = (0, repo_manager_1.stageChanges)(patterns, projectRoot);
     if (stagedNow.length === 0) {
-        console.log(`${spinner_1.colors.yellow('⚠')} No changes matched the pattern(s): ${patterns.join(', ')}`);
+        (0, spinner_1.warning)(`No changes matched the pattern(s): ${patterns.join(', ')}`);
         console.log('');
         return;
     }
-    console.log(`${spinner_1.colors.green('✓')} Staged ${stagedNow.length} change(s):`);
+    console.log(`Staged ${stagedNow.length} change(s):`);
     console.log('');
     for (const change of stagedNow) {
         const display = (0, change_tracker_1.getChangeDisplayName)(change);
@@ -64,7 +469,7 @@ async function addCommand(context) {
         console.log(`${spinner_1.colors.muted(`${remainingUnstaged.length} change(s) still unstaged`)}`);
         console.log('');
     }
-    console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "message"')} ${spinner_1.colors.muted('to commit.')}`);
+    console.log(`hint: run 'relq commit -m "message"' to commit`);
     console.log('');
 }
 function getRelatedChanges(tableName, changes) {

package/dist/cjs/cli/commands/branch.cjs

@@ -0,0 +1,131 @@
+"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.branchCommand = branchCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+function loadBranchState(projectRoot) {
+    const branchPath = path.join(projectRoot, '.relq', 'branches.json');
+    if (fs.existsSync(branchPath)) {
+        return JSON.parse(fs.readFileSync(branchPath, 'utf-8'));
+    }
+    const head = (0, repo_manager_1.getHead)(projectRoot);
+    return {
+        current: 'main',
+        branches: { main: head || '' }
+    };
+}
+function saveBranchState(state, projectRoot) {
+    const branchPath = path.join(projectRoot, '.relq', 'branches.json');
+    fs.writeFileSync(branchPath, JSON.stringify(state, null, 2));
+}
+async function branchCommand(context) {
+    const { args, flags, projectRoot } = context;
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        (0, spinner_1.fatal)('not a relq repository (or any parent directories): .relq', `Run ${spinner_1.colors.cyan('relq init')} to initialize.`);
+    }
+    const state = loadBranchState(projectRoot);
+    const deleteFlag = flags['d'] === true || flags['delete'] === true;
+    const renameFlag = flags['m'] === true || flags['move'] === true;
+    if (deleteFlag) {
+        const branchName = args[0];
+        if (!branchName) {
+            (0, spinner_1.fatal)('Please specify branch name', `Usage: ${spinner_1.colors.cyan('relq branch -d <name>')}`);
+        }
+        if (branchName === state.current) {
+            (0, spinner_1.fatal)(`Cannot delete the branch '${branchName}' which you are currently on`);
+        }
+        if (!state.branches[branchName]) {
+            (0, spinner_1.fatal)(`Branch '${branchName}' not found`, `Use ${spinner_1.colors.cyan('relq branch')} to list available branches.`);
+        }
+        delete state.branches[branchName];
+        saveBranchState(state, projectRoot);
+        console.log(`Deleted branch '${branchName}'`);
+        console.log('');
+        return;
+    }
+    if (renameFlag) {
+        const oldName = args[0];
+        const newName = args[1];
+        if (!oldName || !newName) {
+            (0, spinner_1.fatal)('Missing arguments', `Usage: ${spinner_1.colors.cyan('relq branch -m <old> <new>')}`);
+        }
+        if (!state.branches[oldName]) {
+            (0, spinner_1.fatal)(`Branch '${oldName}' not found`, `Use ${spinner_1.colors.cyan('relq branch')} to list available branches.`);
+        }
+        if (state.branches[newName]) {
+            (0, spinner_1.fatal)(`A branch named '${newName}' already exists`);
+        }
+        state.branches[newName] = state.branches[oldName];
+        delete state.branches[oldName];
+        if (state.current === oldName)
+            state.current = newName;
+        saveBranchState(state, projectRoot);
+        console.log(`Renamed '${oldName}' to '${newName}'`);
+        console.log('');
+        return;
+    }
+    if (args[0]) {
+        const branchName = args[0];
+        if (state.branches[branchName]) {
+            (0, spinner_1.fatal)(`A branch named '${branchName}' already exists`);
+        }
+        const head = (0, repo_manager_1.getHead)(projectRoot);
+        if (!head) {
+            (0, spinner_1.fatal)('No commits yet', `Run ${spinner_1.colors.cyan('relq pull')} or ${spinner_1.colors.cyan('relq import')} first.`);
+        }
+        state.branches[branchName] = head;
+        saveBranchState(state, projectRoot);
+        console.log(`Created branch '${branchName}'`);
+        console.log('');
+        return;
+    }
+    const branches = Object.keys(state.branches).sort();
+    if (branches.length === 0) {
+        console.log(`${spinner_1.colors.muted('No branches.')}`);
+        return;
+    }
+    for (const name of branches) {
+        const isCurrent = name === state.current;
+        const prefix = isCurrent ? spinner_1.colors.green('* ') : '  ';
+        const branchName = isCurrent ? spinner_1.colors.green(name) : name;
+        console.log(`${prefix}${branchName}`);
+    }
+    console.log('');
+}
+exports.default = branchCommand;