|
| 1 | +// src/core.ts |
| 2 | +import fs2 from "fs"; |
| 3 | +import cp from "child_process"; |
| 4 | + |
| 5 | +// src/config.ts |
| 6 | +import fs from "fs"; |
| 7 | +import path from "path"; |
| 8 | +var DEFAULTS = { |
| 9 | + includePatterns: ["*"], |
| 10 | + format: "[${ticket}] ${msg}", |
| 11 | + fallbackFormat: "[${seg0}] ${msg}", |
| 12 | + exclude: ["merge", "squash", "revert"] |
| 13 | +}; |
| 14 | +function loadConfig(cwd) { |
| 15 | + try { |
| 16 | + const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8")); |
| 17 | + const pkgCfg = pkg.commitFromBranch; |
| 18 | + const cfg = pkgCfg ?? {}; |
| 19 | + const include = cfg.includePattern ?? "*"; |
| 20 | + return { |
| 21 | + includePatterns: Array.isArray(include) ? include : [include], |
| 22 | + format: cfg.format ?? DEFAULTS.format, |
| 23 | + fallbackFormat: cfg.fallbackFormat ?? DEFAULTS.fallbackFormat, |
| 24 | + exclude: (cfg.exclude ?? DEFAULTS.exclude).map(String) |
| 25 | + }; |
| 26 | + } catch { |
| 27 | + return { ...DEFAULTS }; |
| 28 | + } |
| 29 | +} |
| 30 | + |
| 31 | +// src/tokens.ts |
| 32 | +function renderTemplate(tpl, ctx) { |
| 33 | + let out = String(tpl); |
| 34 | + out = out.replace(/\$\{prefix:(\d+)\}/g, (_m, n) => { |
| 35 | + const k = Math.max(0, parseInt(n, 10) || 0); |
| 36 | + return ctx.segs.slice(0, k).join("/") || ""; |
| 37 | + }); |
| 38 | + out = out.replace(/\$\{seg(\d+)\}/g, (_m, i) => { |
| 39 | + const idx = parseInt(i, 10) || 0; |
| 40 | + return ctx.segs[idx] || ""; |
| 41 | + }); |
| 42 | + return out.replace(/\$\{ticket\}/g, ctx.ticket || "").replace(/\$\{branch\}/g, ctx.branch || "").replace(/\$\{segments\}/g, ctx.segs.join("/")).replace(/\$\{msg\}/g, ctx.msg || "").replace(/\$\{body\}/g, ctx.body || ""); |
| 43 | +} |
| 44 | + |
| 45 | +// src/core.ts |
| 46 | +var createRegexPattern = (pattern) => new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$", "i"); |
| 47 | +var matchesAnyPattern = (value, patterns) => patterns.some((pattern) => createRegexPattern(pattern).test(value)); |
| 48 | +var parseEnvironmentFlag = (env, key) => /^(1|true|yes)$/i.test(String(env[key] || "")); |
| 49 | +var extractTicketFromBranch = (branch) => (branch.match(/([A-Z]+-\d+)/i)?.[1] || "").toUpperCase(); |
| 50 | +var getCurrentBranch = () => { |
| 51 | + try { |
| 52 | + return cp.execSync("git rev-parse --abbrev-ref HEAD", { |
| 53 | + stdio: ["ignore", "pipe", "ignore"] |
| 54 | + }).toString().trim(); |
| 55 | + } catch { |
| 56 | + return ""; |
| 57 | + } |
| 58 | +}; |
| 59 | +var escapeRegexSpecialChars = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); |
| 60 | +var createLogger = (debug) => (...args) => { |
| 61 | + if (debug) console.log("[cfb]", ...args); |
| 62 | +}; |
| 63 | +var createInitialState = (opts = {}) => { |
| 64 | + const argv = opts.argv ?? process.argv; |
| 65 | + const env = opts.env ?? process.env; |
| 66 | + const cwd = opts.cwd ?? process.cwd(); |
| 67 | + const [, , commitMsgPath, source] = argv; |
| 68 | + if (!commitMsgPath) return null; |
| 69 | + const config = loadConfig(cwd); |
| 70 | + const branch = getCurrentBranch(); |
| 71 | + const ticket = extractTicketFromBranch(branch); |
| 72 | + const debug = parseEnvironmentFlag(env, "BRANCH_PREFIX_DEBUG"); |
| 73 | + const isDryRun = parseEnvironmentFlag(env, "BRANCH_PREFIX_DRYRUN"); |
| 74 | + let originalMessage = ""; |
| 75 | + let lines = []; |
| 76 | + try { |
| 77 | + const body = fs2.readFileSync(commitMsgPath, "utf8"); |
| 78 | + lines = body.split("\n"); |
| 79 | + originalMessage = lines[0] ?? ""; |
| 80 | + } catch { |
| 81 | + } |
| 82 | + const segs = branch.split("/"); |
| 83 | + const template = ticket ? config.format : config.fallbackFormat; |
| 84 | + const context = { branch, segs, ticket, msg: originalMessage, body: lines.join("\n") }; |
| 85 | + const renderedMessage = renderTemplate(template, context); |
| 86 | + return { |
| 87 | + commitMsgPath, |
| 88 | + source, |
| 89 | + config, |
| 90 | + branch, |
| 91 | + ticket, |
| 92 | + originalMessage, |
| 93 | + lines, |
| 94 | + context, |
| 95 | + template, |
| 96 | + renderedMessage, |
| 97 | + shouldSkip: false, |
| 98 | + isDryRun, |
| 99 | + debug |
| 100 | + }; |
| 101 | +}; |
| 102 | +var validationRules = [ |
| 103 | + { |
| 104 | + name: "source-exclusion", |
| 105 | + check: (state) => !state.source || !state.config.exclude.some( |
| 106 | + (pattern) => new RegExp(pattern, "i").test(String(state.source)) |
| 107 | + ), |
| 108 | + reason: "excluded by source" |
| 109 | + }, |
| 110 | + { |
| 111 | + name: "branch-existence", |
| 112 | + check: (state) => Boolean(state.branch && state.branch !== "HEAD"), |
| 113 | + reason: "no branch or detached HEAD" |
| 114 | + }, |
| 115 | + { |
| 116 | + name: "include-pattern-match", |
| 117 | + check: (state) => matchesAnyPattern(state.branch, state.config.includePatterns), |
| 118 | + reason: "includePattern mismatch" |
| 119 | + } |
| 120 | +]; |
| 121 | +var messageProcessors = [ |
| 122 | + { |
| 123 | + name: "template-replacement", |
| 124 | + shouldApply: (state) => /\$\{msg\}|\$\{body\}/.test(state.template), |
| 125 | + process: (state) => { |
| 126 | + if (state.originalMessage === state.renderedMessage) { |
| 127 | + return { ...state, shouldSkip: true, skipReason: "message already matches template" }; |
| 128 | + } |
| 129 | + return { |
| 130 | + ...state, |
| 131 | + lines: [state.renderedMessage, ...state.lines.slice(1)] |
| 132 | + }; |
| 133 | + } |
| 134 | + }, |
| 135 | + { |
| 136 | + name: "prefix-addition", |
| 137 | + shouldApply: (state) => !/\$\{msg\}|\$\{body\}/.test(state.template), |
| 138 | + process: (state) => { |
| 139 | + const escaped = escapeRegexSpecialChars(state.renderedMessage); |
| 140 | + if (new RegExp("^\\s*" + escaped, "i").test(state.originalMessage)) { |
| 141 | + return { ...state, shouldSkip: true, skipReason: "prefix already exists" }; |
| 142 | + } |
| 143 | + if (state.ticket) { |
| 144 | + const ticketRegex = new RegExp(`\\b${escapeRegexSpecialChars(state.ticket)}\\b`, "i"); |
| 145 | + if (ticketRegex.test(state.originalMessage)) { |
| 146 | + return { ...state, shouldSkip: true, skipReason: "ticket already in message" }; |
| 147 | + } |
| 148 | + } |
| 149 | + const firstSeg = state.context.segs[0]; |
| 150 | + if (firstSeg && firstSeg !== "HEAD") { |
| 151 | + const segRegex = new RegExp(`\\b${escapeRegexSpecialChars(firstSeg)}\\b`, "i"); |
| 152 | + if (segRegex.test(state.originalMessage)) { |
| 153 | + return { ...state, shouldSkip: true, skipReason: "branch segment already in message" }; |
| 154 | + } |
| 155 | + } |
| 156 | + return { |
| 157 | + ...state, |
| 158 | + lines: [state.renderedMessage + state.originalMessage, ...state.lines.slice(1)] |
| 159 | + }; |
| 160 | + } |
| 161 | + } |
| 162 | +]; |
| 163 | +var applyValidationRules = (state) => { |
| 164 | + const log = createLogger(state.debug); |
| 165 | + log("config", state.config); |
| 166 | + for (const rule of validationRules) { |
| 167 | + if (!rule.check(state)) { |
| 168 | + log(`exit: ${rule.reason}`, rule.name); |
| 169 | + return { ...state, shouldSkip: true, skipReason: rule.reason }; |
| 170 | + } |
| 171 | + } |
| 172 | + return state; |
| 173 | +}; |
| 174 | +var logProcessingInfo = (state) => { |
| 175 | + const log = createLogger(state.debug); |
| 176 | + const hasMsgToken = /\$\{msg\}|\$\{body\}/.test(state.template); |
| 177 | + log("branch", state.branch, "ticket", state.ticket || "(none)"); |
| 178 | + log("tpl", state.template); |
| 179 | + log("rendered", state.renderedMessage); |
| 180 | + log("mode", hasMsgToken ? "replace-line" : "prefix-only"); |
| 181 | + return state; |
| 182 | +}; |
| 183 | +var processMessage = (state) => { |
| 184 | + if (state.shouldSkip) return state; |
| 185 | + const applicableProcessor = messageProcessors.find( |
| 186 | + (processor) => processor.shouldApply(state) |
| 187 | + ); |
| 188 | + if (!applicableProcessor) { |
| 189 | + return { ...state, shouldSkip: true, skipReason: "no applicable processor" }; |
| 190 | + } |
| 191 | + return applicableProcessor.process(state); |
| 192 | +}; |
| 193 | +var writeResult = (state) => { |
| 194 | + const log = createLogger(state.debug); |
| 195 | + if (state.shouldSkip) { |
| 196 | + log(`skip: ${state.skipReason}`); |
| 197 | + return state; |
| 198 | + } |
| 199 | + if (state.isDryRun) { |
| 200 | + log("dry-run: not writing"); |
| 201 | + return state; |
| 202 | + } |
| 203 | + try { |
| 204 | + fs2.writeFileSync(state.commitMsgPath, state.lines.join("\n"), "utf8"); |
| 205 | + log("write ok"); |
| 206 | + } catch (error) { |
| 207 | + log("write error:", error); |
| 208 | + } |
| 209 | + return state; |
| 210 | +}; |
| 211 | +var pipe = (...functions) => (value) => functions.reduce((acc, fn) => fn(acc), value); |
| 212 | +function run(opts = {}) { |
| 213 | + const initialState = createInitialState(opts); |
| 214 | + if (!initialState) return 0; |
| 215 | + const pipeline = pipe( |
| 216 | + applyValidationRules, |
| 217 | + logProcessingInfo, |
| 218 | + processMessage, |
| 219 | + writeResult |
| 220 | + ); |
| 221 | + pipeline(initialState); |
| 222 | + return 0; |
| 223 | +} |
| 224 | + |
| 225 | +export { |
| 226 | + createInitialState, |
| 227 | + validationRules, |
| 228 | + messageProcessors, |
| 229 | + applyValidationRules, |
| 230 | + processMessage, |
| 231 | + run |
| 232 | +}; |
0 commit comments