relq 1.0.2 → 1.0.4

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

@@ -1,26 +1,413 @@
 "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 allUnstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
-    const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
     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 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);
@@ -44,41 +431,30 @@ async function addCommand(context) {
     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(`${spinner_1.colors.green('✓')} No stageable changes`);
+            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);
@@ -93,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

@@ -54,12 +54,10 @@ function saveBranchState(state, projectRoot) {
     fs.writeFileSync(branchPath, JSON.stringify(state, null, 2));
 }
 async function branchCommand(context) {
-    const { args, flags } = context;
-    const projectRoot = process.cwd();
+    const { args, flags, projectRoot } = context;
     console.log('');
     if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
-        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
-        return;
+        (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;
@@ -67,20 +65,17 @@ async function branchCommand(context) {
     if (deleteFlag) {
         const branchName = args[0];
         if (!branchName) {
-            console.log(`${spinner_1.colors.red('error:')} Please specify branch name`);
-            return;
+            (0, spinner_1.fatal)('Please specify branch name', `Usage: ${spinner_1.colors.cyan('relq branch -d <name>')}`);
         }
         if (branchName === state.current) {
-            console.log(`${spinner_1.colors.red('error:')} Cannot delete current branch`);
-            return;
+            (0, spinner_1.fatal)(`Cannot delete the branch '${branchName}' which you are currently on`);
         }
         if (!state.branches[branchName]) {
-            console.log(`${spinner_1.colors.red('error:')} Branch not found: ${branchName}`);
-            return;
+            (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(`${spinner_1.colors.green('✓')} Deleted branch '${branchName}'`);
+        console.log(`Deleted branch '${branchName}'`);
         console.log('');
         return;
     }
@@ -88,40 +83,35 @@ async function branchCommand(context) {
         const oldName = args[0];
         const newName = args[1];
         if (!oldName || !newName) {
-            console.log(`${spinner_1.colors.red('error:')} Usage: relq branch -m <old> <new>`);
-            return;
+            (0, spinner_1.fatal)('Missing arguments', `Usage: ${spinner_1.colors.cyan('relq branch -m <old> <new>')}`);
         }
         if (!state.branches[oldName]) {
-            console.log(`${spinner_1.colors.red('error:')} Branch not found: ${oldName}`);
-            return;
+            (0, spinner_1.fatal)(`Branch '${oldName}' not found`, `Use ${spinner_1.colors.cyan('relq branch')} to list available branches.`);
         }
         if (state.branches[newName]) {
-            console.log(`${spinner_1.colors.red('error:')} Branch already exists: ${newName}`);
-            return;
+            (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(`${spinner_1.colors.green('✓')} Renamed '${oldName}' to '${newName}'`);
+        console.log(`Renamed '${oldName}' to '${newName}'`);
         console.log('');
         return;
     }
     if (args[0]) {
         const branchName = args[0];
         if (state.branches[branchName]) {
-            console.log(`${spinner_1.colors.red('error:')} Branch already exists: ${branchName}`);
-            return;
+            (0, spinner_1.fatal)(`A branch named '${branchName}' already exists`);
         }
         const head = (0, repo_manager_1.getHead)(projectRoot);
         if (!head) {
-            console.log(`${spinner_1.colors.red('error:')} No commits yet`);
-            return;
+            (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(`${spinner_1.colors.green('✓')} Created branch '${branchName}'`);
+        console.log(`Created branch '${branchName}'`);
         console.log('');
         return;
     }

package/dist/cjs/cli/commands/checkout.cjs

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkoutCommand = checkoutCommand;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const spinner_1 = require("../utils/spinner.cjs");
+const cli_utils_1 = require("../utils/cli-utils.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 function loadBranchState(projectRoot) {
     const branchPath = path.join(projectRoot, '.relq', 'branches.json');
@@ -51,60 +51,48 @@ function saveBranchState(state, projectRoot) {
     fs.writeFileSync(branchPath, JSON.stringify(state, null, 2));
 }
 async function checkoutCommand(context) {
-    const { args, flags } = context;
-    const projectRoot = process.cwd();
+    const { args, flags, projectRoot } = context;
     console.log('');
     if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
-        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
-        return;
+        (0, cli_utils_1.fatal)('not a relq repository (or any parent directories): .relq', "run 'relq init' to initialize");
     }
     const createBranch = flags['b'] === true;
     const branchName = args[0];
     if (!branchName) {
-        console.log(`${spinner_1.colors.red('error:')} Please specify a branch`);
-        console.log('');
-        console.log(`Usage: ${spinner_1.colors.cyan('relq checkout <branch>')}`);
-        console.log(`       ${spinner_1.colors.cyan('relq checkout -b <new-branch>')}`);
-        console.log('');
+        (0, cli_utils_1.error)('please specify a branch');
+        console.log("usage: relq checkout <branch>");
+        console.log("       relq checkout -b <new-branch>");
         return;
     }
     const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
     const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
     if (staged.length > 0 || unstaged.length > 0) {
-        console.log(`${spinner_1.colors.red('error:')} You have uncommitted changes`);
-        console.log('');
-        console.log('Commit or stash them before switching branches:');
-        console.log(`  ${spinner_1.colors.cyan('relq commit -m "message"')}`);
-        console.log(`  ${spinner_1.colors.cyan('relq stash')}`);
-        console.log('');
+        (0, cli_utils_1.error)('you have uncommitted changes');
+        (0, cli_utils_1.hint)("run 'relq commit -m <message>' to commit");
+        (0, cli_utils_1.hint)("run 'relq stash' to stash changes");
         return;
     }
     const state = loadBranchState(projectRoot);
     if (createBranch) {
         if (state.branches[branchName]) {
-            console.log(`${spinner_1.colors.red('error:')} Branch already exists: ${branchName}`);
-            return;
+            (0, cli_utils_1.fatal)(`branch '${branchName}' already exists`);
         }
         const head = (0, repo_manager_1.getHead)(projectRoot);
         if (!head) {
-            console.log(`${spinner_1.colors.red('error:')} No commits yet`);
-            return;
+            (0, cli_utils_1.fatal)('no commits yet', "run 'relq pull' or 'relq import' first");
         }
         state.branches[branchName] = head;
         state.current = branchName;
         saveBranchState(state, projectRoot);
-        console.log(`${spinner_1.colors.green('✓')} Switched to new branch '${branchName}'`);
-        console.log('');
+        console.log(`Switched to a new branch '${branchName}'`);
         return;
     }
     if (!state.branches[branchName]) {
-        console.log(`${spinner_1.colors.red('error:')} Branch not found: ${branchName}`);
-        console.log('');
+        (0, cli_utils_1.error)(`pathspec '${branchName}' did not match any branch known to relq`);
         console.log('Available branches:');
         for (const name of Object.keys(state.branches)) {
-            console.log(`   ${name}`);
+            console.log(`  ${name}`);
         }
-        console.log('');
         return;
     }
     if (state.current === branchName) {
@@ -119,8 +107,7 @@ async function checkoutCommand(context) {
     const targetHash = state.branches[branchName];
     const targetCommit = (0, repo_manager_1.loadCommit)(targetHash, projectRoot);
     if (!targetCommit) {
-        console.log(`${spinner_1.colors.red('error:')} Cannot find commit for branch`);
-        return;
+        (0, cli_utils_1.fatal)('cannot find commit for branch');
     }
     if (targetCommit.schema) {
         (0, repo_manager_1.saveSnapshot)(targetCommit.schema, projectRoot);
@@ -128,7 +115,7 @@ async function checkoutCommand(context) {
     (0, repo_manager_1.setHead)(targetHash, projectRoot);
     state.current = branchName;
     saveBranchState(state, projectRoot);
-    console.log(`${spinner_1.colors.green('✓')} Switched to branch '${branchName}'`);
+    console.log(`Switched to branch '${branchName}'`);
     console.log('');
 }
 exports.default = checkoutCommand;