@quikcommit/cli 7.0.0 → 9.0.0

package/dist/index.js

@@ -32,6 +32,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../shared/dist/types.js
 var init_types = __esm({
@@ -61,6 +62,80 @@ var init_rules = __esm({
   }
 });
 
+// ../shared/dist/tokens.js
+function estimateTokens(text) {
+  return Math.ceil(text.length / 2.5);
+}
+var init_tokens = __esm({
+  "../shared/dist/tokens.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/branch.js
+function validateBranchName(name) {
+  if (typeof name !== "string")
+    return false;
+  if (name.length > MAX_BRANCH_NAME_LENGTH)
+    return false;
+  if (!BRANCH_NAME_RX.test(name))
+    return false;
+  if (PROTECTED_BRANCH_RX.test(name))
+    return false;
+  return true;
+}
+function slugifyFilename(path) {
+  const basename = path.split("/").pop() ?? path;
+  const noExt = basename.replace(/\.[^.]+$/, "");
+  return noExt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+function deterministicBranchName(opts) {
+  const files = opts.files ?? [];
+  const haystack = `${opts.description ?? ""} ${files.join(" ")}`;
+  let type = "chore";
+  for (const [rx, t] of TYPE_HINTS) {
+    if (rx.test(haystack)) {
+      type = t;
+      break;
+    }
+  }
+  let slug;
+  if (opts.description) {
+    slug = opts.description.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").split("-").slice(0, 5).join("-").slice(0, 40);
+  } else if (files.length > 0) {
+    slug = slugifyFilename(files[0] ?? "");
+  } else {
+    slug = "changes";
+  }
+  if (!slug)
+    slug = "changes";
+  if (slug.length === 1)
+    slug = `${slug}-changes`;
+  const name = `${type}/${slug}`;
+  if (!validateBranchName(name)) {
+    return { type: "chore", slug: "updates", name: "chore/updates" };
+  }
+  return { name, type, slug };
+}
+var BRANCH_NAME_RX, PROTECTED_BRANCH_RX, MAX_BRANCH_NAME_LENGTH, TYPE_HINTS;
+var init_branch = __esm({
+  "../shared/dist/branch.js"() {
+    "use strict";
+    BRANCH_NAME_RX = /^(feat|fix|refactor|perf|docs|test|chore|ci)\/[a-z0-9][a-z0-9-]{0,51}$/;
+    PROTECTED_BRANCH_RX = /(^|[/-])(main|master|develop|trunk|release)([/-]|$)/i;
+    MAX_BRANCH_NAME_LENGTH = 60;
+    TYPE_HINTS = [
+      [/\btest|spec\b/i, "test"],
+      [/\bdocs?\b|readme|\.md$/i, "docs"],
+      [/\bperf|benchmark/i, "perf"],
+      [/\brefactor\b/i, "refactor"],
+      [/\bci|workflow|github\/actions/i, "ci"],
+      [/\bfix|bug|issue/i, "fix"],
+      [/\bfeat|add|new\b/i, "feat"]
+    ];
+  }
+});
+
 // ../shared/dist/index.js
 var init_dist = __esm({
   "../shared/dist/index.js"() {
@@ -68,10 +143,20 @@ var init_dist = __esm({
     init_types();
     init_constants();
     init_rules();
+    init_tokens();
+    init_branch();
   }
 });
 
 // src/config.ts
+var config_exports = {};
+__export(config_exports, {
+  clearApiKey: () => clearApiKey,
+  getApiKey: () => getApiKey,
+  getConfig: () => getConfig,
+  saveApiKey: () => saveApiKey,
+  saveConfig: () => saveConfig
+});
 function getApiKey() {
   const envKey = process.env.QC_API_KEY;
   if (envKey?.trim()) return envKey.trim();
@@ -125,6 +210,149 @@ var init_config = __esm({
   }
 });
 
+// src/commands/login.ts
+var login_exports = {};
+__export(login_exports, {
+  runLogin: () => runLogin
+});
+function openBrowser(url) {
+  try {
+    if ((0, import_os2.platform)() === "darwin") {
+      (0, import_child_process.execFileSync)("open", [url], { stdio: "pipe" });
+      return true;
+    }
+    if ((0, import_os2.platform)() === "linux") {
+      (0, import_child_process.execFileSync)("xdg-open", [url], { stdio: "pipe" });
+      return true;
+    }
+    if ((0, import_os2.platform)() === "win32") {
+      (0, import_child_process.execFileSync)("cmd", ["/c", "start", "", url], { stdio: "pipe" });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+async function runLogin() {
+  const codeRes = await fetch(`${API_URL}/api/auth/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client_id: CLIENT_ID })
+  });
+  if (!codeRes.ok) {
+    const err = await codeRes.json().catch(() => ({ error: codeRes.statusText }));
+    throw new Error(err.error ?? "Failed to start device flow");
+  }
+  const codeData = await codeRes.json();
+  const { device_code, user_code, verification_uri_complete, interval = 5 } = codeData;
+  if (!device_code || !user_code) {
+    throw new Error("Server did not return device codes");
+  }
+  console.log("Opening browser to sign in...");
+  console.log("");
+  console.log(`  Your code: ${user_code}`);
+  console.log("");
+  const authUrl = verification_uri_complete ?? `${DASHBOARD_URL}/device?user_code=${encodeURIComponent(user_code)}`;
+  const opened = openBrowser(authUrl);
+  if (!opened) {
+    console.log("Could not open browser. Please visit:");
+    console.log(authUrl);
+    console.log("");
+  }
+  let frame = 0;
+  const spinner = setInterval(() => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1e3);
+    process.stderr.write(
+      `\r${SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length]} Waiting for authorization... (${elapsed}s)`
+    );
+  }, 80);
+  let pollingInterval = interval * 1e3;
+  const startTime = Date.now();
+  try {
+    while (Date.now() - startTime < DEVICE_FLOW_TIMEOUT) {
+      await new Promise((r) => setTimeout(r, pollingInterval));
+      try {
+        const tokenRes = await fetch(`${API_URL}/api/auth/device/token`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+            device_code,
+            client_id: CLIENT_ID
+          })
+        });
+        const tokenData = await tokenRes.json();
+        if (tokenData.access_token) {
+          saveApiKey(tokenData.access_token);
+          process.stderr.write("\r\x1B[2K");
+          console.log("Successfully logged in!");
+          return;
+        }
+        if (tokenData.error) {
+          switch (tokenData.error) {
+            case "authorization_pending":
+              break;
+            // continue polling
+            case "slow_down":
+              pollingInterval += 5e3;
+              break;
+            case "access_denied":
+              process.stderr.write("\r\x1B[2K");
+              console.error("Authorization was denied.");
+              process.exit(1);
+              break;
+            case "expired_token":
+              process.stderr.write("\r\x1B[2K");
+              console.error("Device code expired. Please try again.");
+              process.exit(1);
+              break;
+            default:
+              process.stderr.write("\r\x1B[2K");
+              console.error(`Error: ${tokenData.error_description ?? tokenData.error}`);
+              process.exit(1);
+          }
+        }
+      } catch {
+      }
+    }
+    process.stderr.write("\r\x1B[2K");
+    console.error("Login timed out. Please try again.");
+    process.exit(1);
+  } finally {
+    clearInterval(spinner);
+  }
+}
+var import_child_process, import_os2, API_URL, DASHBOARD_URL, CLIENT_ID, SPINNER_FRAMES;
+var init_login = __esm({
+  "src/commands/login.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    import_os2 = require("os");
+    init_config();
+    init_dist();
+    API_URL = process.env.QC_API_URL ?? DEFAULT_API_URL;
+    DASHBOARD_URL = "https://app.quikcommit.dev";
+    CLIENT_ID = "qc-cli";
+    SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  }
+});
+
+// src/commands/logout.ts
+var logout_exports = {};
+__export(logout_exports, {
+  runLogout: () => runLogout
+});
+function runLogout() {
+  clearApiKey();
+  console.log("Logged out. Credentials cleared.");
+}
+var init_logout = __esm({
+  "src/commands/logout.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
 // src/api.ts
 var ApiClient;
 var init_api = __esm({
@@ -155,6 +383,13 @@ var init_api = __esm({
           body: JSON.stringify(body)
         });
         if (!res.ok) {
+          if (res.status === 413) {
+            const errBody = await res.json().catch(() => ({}));
+            const sizeHint = errBody.received_bytes ? ` (${Math.round(errBody.received_bytes / 1024)}KB > ${Math.round((errBody.limit_bytes ?? 0) / 1024)}KB limit)` : "";
+            throw new Error(
+              `Diff too large to send${sizeHint}. Try: qc --exclude '*.lock' --exclude 'dist/**' (or commit fewer files at a time).`
+            );
+          }
           const err = await res.json().catch(() => ({ error: res.statusText }));
           if (planRequiredMsg && err.code === "PLAN_REQUIRED") {
             throw new Error(planRequiredMsg);
@@ -163,8 +398,15 @@ var init_api = __esm({
         }
         return res.json();
       }
-      async generateCommit(diff, changes, rules, model) {
-        const body = { diff, changes, rules, model };
+      async generateCommit(diff, changes, rules, model, recentCommits, generationHints) {
+        const body = {
+          diff,
+          changes,
+          rules,
+          model,
+          recent_commits: recentCommits,
+          ...generationHints && Object.keys(generationHints).length > 0 ? { generation_hints: generationHints } : {}
+        };
         const data = await this.request(
           "/v1/commit",
           body
@@ -194,6 +436,9 @@ var init_api = __esm({
           summary: data.summary ?? ""
         };
       }
+      async generateBranchName(req) {
+        return this.request("/v1/branch", req);
+      }
       async fetchJson(endpoint, options) {
         if (!this.apiKey) {
           throw new Error("Not authenticated. Run `qc login` first.");
@@ -248,6 +493,37 @@ var init_api = __esm({
   }
 });
 
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  runStatus: () => runStatus
+});
+async function runStatus(apiKeyFlag) {
+  const apiKey = apiKeyFlag ?? getApiKey();
+  if (!apiKey) {
+    console.log("Not logged in. Run `qc login` to authenticate.");
+    return;
+  }
+  console.log("Logged in: yes");
+  console.log(`  API key: ...${apiKey.slice(-4)}`);
+  const client = new ApiClient({ apiKey });
+  const usage = await client.getUsage();
+  if (usage) {
+    console.log(`Plan: ${usage.plan}`);
+    console.log(`Usage: ${usage.commit_count}/${usage.limit} commits this period`);
+    console.log(`Remaining: ${usage.remaining}`);
+  } else {
+    console.log("Usage: (unable to fetch)");
+  }
+}
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_config();
+    init_api();
+  }
+});
+
 // ../../node_modules/.pnpm/yaml@2.8.4/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
   "../../node_modules/.pnpm/yaml@2.8.4/node_modules/yaml/dist/nodes/identity.js"(exports2) {
@@ -7558,13 +7834,16 @@ var require_dist = __commonJS({
 
 // src/git.ts
 function validateRef(ref, name = "ref") {
+  if (ref.startsWith("-")) {
+    throw new Error(`Invalid git ref ${name}: starts with hyphen: "${ref}"`);
+  }
   if (!ref || !SAFE_GIT_REF.test(ref)) {
     throw new Error(`Invalid git ref ${name}: "${ref}"`);
   }
 }
 function isGitRepo() {
   try {
-    (0, import_child_process.execFileSync)("git", ["rev-parse", "--is-inside-work-tree"], {
+    (0, import_child_process2.execFileSync)("git", ["rev-parse", "--is-inside-work-tree"], {
       stdio: "pipe"
     });
     return true;
@@ -7574,7 +7853,7 @@ function isGitRepo() {
 }
 function getGitRoot() {
   try {
-    return (0, import_child_process.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+    return (0, import_child_process2.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -7590,37 +7869,37 @@ function getStagedDiff(excludes = []) {
       args.push(`:(exclude)${pattern}`);
     }
   }
-  return (0, import_child_process.execFileSync)("git", args, {
+  return (0, import_child_process2.execFileSync)("git", args, {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
 }
 function getStagedFiles() {
-  return (0, import_child_process.execFileSync)("git", ["diff", "--cached", "--name-only"], {
+  return (0, import_child_process2.execFileSync)("git", ["diff", "--cached", "--name-only"], {
     encoding: "utf-8"
   });
 }
 function hasStagedChanges() {
-  const output = (0, import_child_process.execFileSync)("git", ["diff", "--cached", "--name-only"], {
+  const output = (0, import_child_process2.execFileSync)("git", ["diff", "--cached", "--name-only"], {
     encoding: "utf-8"
   });
   return output.trim().length > 0;
 }
 function getUnstagedFiles() {
-  const output = (0, import_child_process.execFileSync)("git", ["status", "--porcelain"], {
+  const output = (0, import_child_process2.execFileSync)("git", ["status", "--porcelain"], {
     encoding: "utf-8"
   });
   return output.trim().split("\n").filter(Boolean).filter((line) => !line.startsWith("??"));
 }
 function stageAll() {
-  (0, import_child_process.execFileSync)("git", ["add", "-u"], { stdio: "pipe" });
+  (0, import_child_process2.execFileSync)("git", ["add", "-u"], { stdio: "pipe" });
 }
 function gitCommit(message) {
-  const tmpDir = (0, import_fs2.mkdtempSync)((0, import_path2.join)((0, import_os2.tmpdir)(), "qc-"));
+  const tmpDir = (0, import_fs2.mkdtempSync)((0, import_path2.join)((0, import_os3.tmpdir)(), "qc-"));
   const tmpFile = (0, import_path2.join)(tmpDir, "commit.txt");
   (0, import_fs2.writeFileSync)(tmpFile, message, { mode: 384 });
   try {
-    (0, import_child_process.execFileSync)("git", ["commit", "-F", tmpFile], { stdio: "inherit" });
+    (0, import_child_process2.execFileSync)("git", ["commit", "-F", tmpFile], { stdio: "inherit" });
   } finally {
     try {
       (0, import_fs2.unlinkSync)(tmpFile);
@@ -7630,11 +7909,11 @@ function gitCommit(message) {
   }
 }
 function gitPush() {
-  (0, import_child_process.execFileSync)("git", ["push"], { stdio: "inherit" });
+  (0, import_child_process2.execFileSync)("git", ["push"], { stdio: "inherit" });
 }
 function getBranchCommits(base = "main") {
   validateRef(base, "base");
-  const output = (0, import_child_process.execFileSync)("git", ["log", `${base}..HEAD`, "--format=%s", "--max-count=1000"], {
+  const output = (0, import_child_process2.execFileSync)("git", ["log", `${base}..HEAD`, "--format=%s", "--max-count=1000"], {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
@@ -7642,19 +7921,19 @@ function getBranchCommits(base = "main") {
 }
 function getDiffStat(base = "main") {
   validateRef(base, "base");
-  return (0, import_child_process.execFileSync)("git", ["diff", `${base}..HEAD`, "--stat"], {
+  return (0, import_child_process2.execFileSync)("git", ["diff", `${base}..HEAD`, "--stat"], {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
 }
 function getCurrentBranch() {
-  return (0, import_child_process.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+  return (0, import_child_process2.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
     encoding: "utf-8"
   }).trim();
 }
 function getLatestTag() {
   try {
-    return (0, import_child_process.execFileSync)("git", ["describe", "--tags", "--abbrev=0"], {
+    return (0, import_child_process2.execFileSync)("git", ["describe", "--tags", "--abbrev=0"], {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -7664,7 +7943,7 @@ function getLatestTag() {
 function getCommitsSince(ref, to = "HEAD") {
   validateRef(ref, "from ref");
   validateRef(to, "to ref");
-  const output = (0, import_child_process.execFileSync)(
+  const output = (0, import_child_process2.execFileSync)(
     "git",
     ["log", `${ref}..${to}`, "--format=%H %s", "--max-count=1000"],
     { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
@@ -7676,7 +7955,7 @@ function getCommitsSince(ref, to = "HEAD") {
 }
 function getChangedFilesSince(base = "main") {
   validateRef(base, "base");
-  const output = (0, import_child_process.execFileSync)("git", ["diff", `${base}..HEAD`, "--name-only"], {
+  const output = (0, import_child_process2.execFileSync)("git", ["diff", `${base}..HEAD`, "--name-only"], {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
@@ -7684,7 +7963,7 @@ function getChangedFilesSince(base = "main") {
 }
 function getOnlineLog(base = "main") {
   validateRef(base, "base");
-  return (0, import_child_process.execFileSync)(
+  return (0, import_child_process2.execFileSync)(
     "git",
     ["log", `${base}..HEAD`, "--oneline", "--max-count=200"],
     {
@@ -7695,55 +7974,217 @@ function getOnlineLog(base = "main") {
 }
 function getFullDiff(base = "main") {
   validateRef(base, "base");
-  return (0, import_child_process.execFileSync)("git", ["diff", `${base}..HEAD`], {
+  return (0, import_child_process2.execFileSync)("git", ["diff", `${base}..HEAD`], {
     encoding: "utf-8",
     maxBuffer: 10 * 1024 * 1024
   });
 }
-var import_child_process, import_fs2, import_path2, import_os2, SAFE_GIT_REF;
-var init_git = __esm({
-  "src/git.ts"() {
-    "use strict";
-    import_child_process = require("child_process");
-    import_fs2 = require("fs");
-    import_path2 = require("path");
-    import_os2 = require("os");
-    SAFE_GIT_REF = /^[a-zA-Z0-9._\-/~:^@]+$/;
-  }
-});
-
-// src/commitlint.ts
-function findConfigFile(root) {
-  for (const file of CONFIG_FILES) {
-    const full = (0, import_path3.join)(root, file);
-    if ((0, import_fs3.existsSync)(full)) return full;
+function getStagedDiffShortstat() {
+  try {
+    const out = (0, import_child_process2.execFileSync)("git", ["diff", "--cached", "--shortstat"], {
+      encoding: "utf-8"
+    }).trim();
+    if (!out) return { additions: 0, deletions: 0 };
+    let additions = 0;
+    let deletions = 0;
+    const ins = /(\d+) insertion/.exec(out);
+    const del = /(\d+) deletion/.exec(out);
+    if (ins?.[1]) additions = parseInt(ins[1], 10);
+    if (del?.[1]) deletions = parseInt(del[1], 10);
+    return { additions, deletions };
+  } catch {
+    return { additions: 0, deletions: 0 };
   }
-  return null;
 }
-function getRule(rules, name) {
-  const r = rules[name];
-  if (!Array.isArray(r) || r.length < 3) return null;
-  const [severity, applicability, value] = r;
-  if (typeof severity !== "number" || severity < 1) return null;
-  return [severity, applicability, value];
+function getShortStagedFiles(max = 3) {
+  const output = (0, import_child_process2.execFileSync)("git", ["diff", "--cached", "--name-only"], {
+    encoding: "utf-8"
+  });
+  const all = output.trim().split("\n").filter(Boolean);
+  return { files: all.slice(0, max), total: all.length };
 }
-function mapRules(rules) {
-  const result = {};
-  const typeEnum = getRule(rules, "type-enum");
-  if (typeEnum && typeEnum[1] === "always" && Array.isArray(typeEnum[2])) {
-    result.types = typeEnum[2].filter((t) => typeof t === "string");
-  }
-  const scopeEnum = getRule(rules, "scope-enum");
-  if (scopeEnum && scopeEnum[1] === "always" && Array.isArray(scopeEnum[2])) {
-    result.scopes = scopeEnum[2].filter((s) => typeof s === "string");
+function getCommitHash() {
+  return (0, import_child_process2.execFileSync)("git", ["rev-parse", "--short", "HEAD"], {
+    encoding: "utf-8"
+  }).trim();
+}
+function getPushStats() {
+  try {
+    const branch = (0, import_child_process2.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      encoding: "utf-8"
+    }).trim();
+    const countOutput = (0, import_child_process2.execFileSync)(
+      "git",
+      ["rev-list", "--count", `origin/${branch}..HEAD`],
+      { encoding: "utf-8" }
+    ).trim();
+    const parsedCount = parseInt(countOutput, 10);
+    const commits = Number.isFinite(parsedCount) ? parsedCount : 0;
+    const stat = (0, import_child_process2.execFileSync)(
+      "git",
+      ["diff", "--shortstat", `origin/${branch}..HEAD`],
+      { encoding: "utf-8" }
+    ).trim();
+    return { commits, stat };
+  } catch {
+    return null;
   }
-  const headerMax = getRule(rules, "header-max-length");
-  if (headerMax && headerMax[1] === "always" && typeof headerMax[2] === "number") {
-    result.headerMaxLength = headerMax[2];
+}
+function getRecentBranchCommits(count = 5) {
+  try {
+    const output = (0, import_child_process2.execFileSync)(
+      "git",
+      ["log", "--format=%s%n%b%n---", `--max-count=${count}`, "HEAD"],
+      { encoding: "utf-8", maxBuffer: 1024 * 1024 }
+    );
+    return output.split("---\n").map((entry) => entry.trim()).filter(Boolean).slice(0, count);
+  } catch {
+    return [];
   }
-  const subjectMax = getRule(rules, "subject-max-length");
-  if (subjectMax && subjectMax[1] === "always" && typeof subjectMax[2] === "number") {
-    result.subjectMaxLength = subjectMax[2];
+}
+function getCommitsAheadOfUpstream(branch, upstream) {
+  validateRef(branch, "branch");
+  const target = upstream ?? `origin/${branch}`;
+  validateRef(target, "upstream");
+  try {
+    const out = (0, import_child_process2.execFileSync)(
+      "git",
+      ["rev-list", "--count", `${target}..HEAD`],
+      { encoding: "utf-8" }
+    ).trim();
+    const n = parseInt(out, 10);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+function getUpstreamRef(branch) {
+  validateRef(branch, "branch");
+  try {
+    return (0, import_child_process2.execFileSync)(
+      "git",
+      ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`],
+      { encoding: "utf-8" }
+    ).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getDefaultBranch() {
+  try {
+    const out = (0, import_child_process2.execFileSync)(
+      "git",
+      ["symbolic-ref", "refs/remotes/origin/HEAD"],
+      { encoding: "utf-8" }
+    ).trim();
+    const segments = out.split("/");
+    return segments[segments.length - 1] || null;
+  } catch {
+    return null;
+  }
+}
+function branchExists(name) {
+  validateRef(name, "branch");
+  try {
+    (0, import_child_process2.execFileSync)("git", ["show-ref", "--verify", "--quiet", `refs/heads/${name}`], {
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+  }
+  try {
+    (0, import_child_process2.execFileSync)("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${name}`], {
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stashPushIfDirty(message) {
+  const status = (0, import_child_process2.execFileSync)("git", ["status", "--porcelain"], { encoding: "utf-8" }).trim();
+  if (!status) return false;
+  (0, import_child_process2.execFileSync)("git", ["stash", "push", "--include-untracked", "--message", message], {
+    stdio: "pipe"
+  });
+  return true;
+}
+function stashPop() {
+  (0, import_child_process2.execFileSync)("git", ["stash", "pop"], { stdio: "pipe" });
+}
+function resetHard(ref) {
+  validateRef(ref, "ref");
+  (0, import_child_process2.execFileSync)("git", ["reset", "--hard", ref], { stdio: "pipe" });
+}
+function createBranch(name, base = "HEAD") {
+  validateRef(name, "name");
+  validateRef(base, "base");
+  (0, import_child_process2.execFileSync)("git", ["branch", name, base], { stdio: "pipe" });
+}
+function checkoutBranch(name) {
+  validateRef(name, "name");
+  (0, import_child_process2.execFileSync)("git", ["checkout", name], { stdio: "pipe" });
+}
+function createAndCheckoutBranch(name, base = "HEAD") {
+  validateRef(name, "name");
+  validateRef(base, "base");
+  (0, import_child_process2.execFileSync)("git", ["checkout", "-b", name, base], { stdio: "pipe" });
+}
+function getHeadSha() {
+  return (0, import_child_process2.execFileSync)("git", ["rev-parse", "HEAD"], { encoding: "utf-8" }).trim();
+}
+function gitPushSetUpstream(branch) {
+  validateRef(branch, "branch");
+  (0, import_child_process2.execFileSync)("git", ["push", "-u", "origin", branch], { stdio: "inherit" });
+}
+function deleteBranch(name) {
+  validateRef(name, "name");
+  (0, import_child_process2.execFileSync)("git", ["branch", "-D", name], { stdio: "pipe" });
+}
+var import_child_process2, import_fs2, import_path2, import_os3, SAFE_GIT_REF;
+var init_git = __esm({
+  "src/git.ts"() {
+    "use strict";
+    import_child_process2 = require("child_process");
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+    import_os3 = require("os");
+    SAFE_GIT_REF = /^[a-zA-Z0-9][a-zA-Z0-9._\-/~:^@]*$/;
+  }
+});
+
+// src/commitlint.ts
+function findConfigFile(root) {
+  for (const file of CONFIG_FILES) {
+    const full = (0, import_path3.join)(root, file);
+    if ((0, import_fs3.existsSync)(full)) return full;
+  }
+  return null;
+}
+function getRule(rules, name) {
+  const r = rules[name];
+  if (!Array.isArray(r) || r.length < 3) return null;
+  const [severity, applicability, value] = r;
+  if (typeof severity !== "number" || severity < 1) return null;
+  return [severity, applicability, value];
+}
+function mapRules(rules) {
+  const result = {};
+  const typeEnum = getRule(rules, "type-enum");
+  if (typeEnum && typeEnum[1] === "always" && Array.isArray(typeEnum[2])) {
+    result.types = typeEnum[2].filter((t) => typeof t === "string");
+  }
+  const scopeEnum = getRule(rules, "scope-enum");
+  if (scopeEnum && scopeEnum[1] === "always" && Array.isArray(scopeEnum[2])) {
+    result.scopes = scopeEnum[2].filter((s) => typeof s === "string");
+  }
+  const headerMax = getRule(rules, "header-max-length");
+  if (headerMax && headerMax[1] === "always" && typeof headerMax[2] === "number") {
+    result.headerMaxLength = headerMax[2];
+  }
+  const subjectMax = getRule(rules, "subject-max-length");
+  if (subjectMax && subjectMax[1] === "always" && typeof subjectMax[2] === "number") {
+    result.subjectMaxLength = subjectMax[2];
   }
   const bodyMaxLine = getRule(rules, "body-max-line-length");
   if (bodyMaxLine && bodyMaxLine[1] === "always" && typeof bodyMaxLine[2] === "number") {
@@ -7774,7 +8215,7 @@ function mapRulesToCommitRules(rules) {
 }
 function tryNpxPrintConfig(root) {
   try {
-    const output = (0, import_child_process2.execFileSync)("npx", ["--no", "commitlint", "--print-config"], {
+    const output = (0, import_child_process3.execFileSync)("npx", ["--no", "commitlint", "--print-config"], {
       encoding: "utf-8",
       cwd: root,
       timeout: 1e4,
@@ -7791,7 +8232,7 @@ function tryNodeEval(configPath) {
   const fileUrl = (0, import_node_url.pathToFileURL)(configPath).href;
   const script = `import cfg from ${JSON.stringify(fileUrl)}; process.stdout.write(JSON.stringify(cfg.default ?? cfg));`;
   try {
-    const output = (0, import_child_process2.execFileSync)("node", ["--input-type=module"], {
+    const output = (0, import_child_process3.execFileSync)("node", ["--input-type=module"], {
       input: script,
       encoding: "utf-8",
       timeout: 1e4,
@@ -7808,7 +8249,7 @@ function tryNodeEvalTs(configPath, root) {
   const fileUrl = (0, import_node_url.pathToFileURL)(configPath).href;
   const script = `import cfg from ${JSON.stringify(fileUrl)}; process.stdout.write(JSON.stringify(cfg.default ?? cfg));`;
   try {
-    const output = (0, import_child_process2.execFileSync)("node", ["--experimental-strip-types", "--input-type=module"], {
+    const output = (0, import_child_process3.execFileSync)("node", ["--experimental-strip-types", "--input-type=module"], {
       input: script,
       encoding: "utf-8",
       cwd: root,
@@ -7822,7 +8263,7 @@ function tryNodeEvalTs(configPath, root) {
   }
   try {
     const tsxScript = `import cfg from ${JSON.stringify(fileUrl)}; console.log(JSON.stringify(cfg.default ?? cfg));`;
-    const output = (0, import_child_process2.execFileSync)("npx", ["--no", "tsx", "-e", tsxScript], {
+    const output = (0, import_child_process3.execFileSync)("npx", ["--no", "tsx", "-e", tsxScript], {
       encoding: "utf-8",
       cwd: root,
       timeout: 15e3,
@@ -7875,11 +8316,11 @@ async function detectCommitlintRules() {
     return void 0;
   }
 }
-var import_child_process2, import_fs3, import_path3, import_node_url, import_yaml, CONFIG_FILES;
+var import_child_process3, import_fs3, import_path3, import_node_url, import_yaml, CONFIG_FILES;
 var init_commitlint = __esm({
   "src/commitlint.ts"() {
     "use strict";
-    import_child_process2 = require("child_process");
+    import_child_process3 = require("child_process");
     import_fs3 = require("fs");
     import_path3 = require("path");
     import_node_url = require("node:url");
@@ -7900,6 +8341,183 @@ var init_commitlint = __esm({
   }
 });
 
+// src/commands/pr.ts
+var pr_exports = {};
+__export(pr_exports, {
+  pr: () => pr
+});
+function findPullRequestTemplate(gitRoot) {
+  const fileCandidates = [
+    (0, import_path4.join)(gitRoot, ".github", "pull_request_template.md"),
+    (0, import_path4.join)(gitRoot, ".github", "PULL_REQUEST_TEMPLATE.md"),
+    (0, import_path4.join)(gitRoot, "pull_request_template.md")
+  ];
+  for (const p of fileCandidates) {
+    try {
+      if ((0, import_fs4.existsSync)(p) && (0, import_fs4.statSync)(p).isFile()) {
+        return { path: p, content: (0, import_fs4.readFileSync)(p, "utf-8") };
+      }
+    } catch {
+    }
+  }
+  const multiDir = (0, import_path4.join)(gitRoot, ".github", "PULL_REQUEST_TEMPLATE");
+  try {
+    if ((0, import_fs4.existsSync)(multiDir) && (0, import_fs4.statSync)(multiDir).isDirectory()) {
+      const names = (0, import_fs4.readdirSync)(multiDir).filter((f) => f.toLowerCase().endsWith(".md")).sort();
+      if (names.length > 0) {
+        const p = (0, import_path4.join)(multiDir, names[0]);
+        if ((0, import_fs4.statSync)(p).isFile()) {
+          return { path: p, content: (0, import_fs4.readFileSync)(p, "utf-8") };
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function pr(options) {
+  const base = options.base ?? "main";
+  const commits = getBranchCommits(base);
+  const diffStat = getDiffStat(base);
+  const gitRoot = getGitRoot();
+  const templateHit = findPullRequestTemplate(gitRoot);
+  let prTemplate;
+  if (templateHit) {
+    prTemplate = templateHit.content.substring(0, 16 * 1024);
+    console.error(`[qc] Using PR template from ${(0, import_path4.relative)(gitRoot, templateHit.path)}`);
+  }
+  const currentBranch = getCurrentBranch().slice(0, MAX_PR_CURRENT_BRANCH_CHARS);
+  if (commits.length === 0) {
+    console.error(`No commits found on this branch vs ${base}`);
+    process.exit(1);
+  }
+  const commitlintRules = await detectCommitlintRules();
+  console.error(`Generating PR description from ${commits.length} commits...`);
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error("Error: Not authenticated. Run `qc login` first.");
+    process.exit(1);
+  }
+  const client = new ApiClient({ apiKey });
+  const result = await client.generatePR(
+    {
+      commits,
+      diff_stat: diffStat,
+      base_branch: base,
+      current_branch: currentBranch,
+      pr_template: prTemplate,
+      rules: commitlintRules
+    },
+    options.model
+  );
+  const trimmedTitle = result.title.trim();
+  if (trimmedTitle) {
+    console.log(`
+Title: ${trimmedTitle}
+`);
+  }
+  console.log(result.message + "\n");
+  if (options.create) {
+    try {
+      const prTitle = trimmedTitle || result.message.split("\n").find((l) => l.trim()) || result.message.substring(0, 72).trim();
+      (0, import_child_process4.execFileSync)("gh", ["pr", "create", "--title", prTitle, "--body", result.message], {
+        stdio: "inherit"
+      });
+    } catch {
+      console.error("Error: `gh` CLI not found or failed. Install from https://cli.github.com/");
+      process.exit(1);
+    }
+  }
+}
+var import_child_process4, import_fs4, import_path4;
+var init_pr = __esm({
+  "src/commands/pr.ts"() {
+    "use strict";
+    import_child_process4 = require("child_process");
+    import_fs4 = require("fs");
+    import_path4 = require("path");
+    init_dist();
+    init_config();
+    init_api();
+    init_commitlint();
+    init_git();
+  }
+});
+
+// src/commands/changelog.ts
+var changelog_exports = {};
+__export(changelog_exports, {
+  changelog: () => changelog
+});
+function parseCommitType(subject) {
+  const match = subject.match(CONVENTIONAL_TYPE_RE);
+  return match ? match[1].toLowerCase() : "chore";
+}
+function groupCommitsByType(commits) {
+  const byType = {};
+  for (const { subject } of commits) {
+    const type = parseCommitType(subject);
+    if (!byType[type]) byType[type] = [];
+    byType[type].push(subject);
+  }
+  return byType;
+}
+async function changelog(options) {
+  const fromRef = options.from ?? getLatestTag();
+  const toRef = options.to ?? "HEAD";
+  if (!fromRef) {
+    console.error("Error: No git tag found. Use --from <ref> to specify a starting point.");
+    process.exit(1);
+  }
+  const commits = getCommitsSince(fromRef, toRef);
+  if (commits.length === 0) {
+    console.error(`No commits found between ${fromRef} and ${toRef}`);
+    process.exit(1);
+  }
+  const commitsByType = groupCommitsByType(commits);
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error("Error: Not authenticated. Run `qc login` first.");
+    process.exit(1);
+  }
+  const client = new ApiClient({ apiKey });
+  const result = await client.generateChangelog(
+    {
+      commits_by_type: commitsByType,
+      from_tag: fromRef,
+      to_ref: toRef
+    },
+    options.model
+  );
+  const version = options.version ?? (/^v?\d/.test(toRef) && toRef !== "HEAD" ? toRef.replace(/^v/, "") : null) ?? `${fromRef.replace(/^v/, "")}-next`;
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const header = `## [${version}] - ${date}
+
+`;
+  const changelogEntry = header + result.message;
+  if (options.write) {
+    const path = (0, import_path5.join)(getGitRoot(), "CHANGELOG.md");
+    const existing = (0, import_fs5.existsSync)(path) ? (0, import_fs5.readFileSync)(path, "utf-8") : "";
+    const newContent = changelogEntry + (existing ? "\n\n" + existing : "");
+    (0, import_fs5.writeFileSync)(path, newContent);
+    console.error(`Wrote to ${path}`);
+  } else {
+    console.log(changelogEntry);
+  }
+}
+var import_fs5, import_path5, CONVENTIONAL_TYPE_RE;
+var init_changelog = __esm({
+  "src/commands/changelog.ts"() {
+    "use strict";
+    import_fs5 = require("fs");
+    import_path5 = require("path");
+    init_config();
+    init_api();
+    init_git();
+    CONVENTIONAL_TYPE_RE = /^(feat|fix|docs|style|refactor|perf|test|chore)(\([^)]+\))?!?:\s+/i;
+  }
+});
+
 // src/monorepo.ts
 var monorepo_exports = {};
 __export(monorepo_exports, {
@@ -7909,7 +8527,7 @@ __export(monorepo_exports, {
 });
 function findGitRoot(start) {
   try {
-    return (0, import_child_process3.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+    return (0, import_child_process5.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf-8",
       cwd: start,
       stdio: ["pipe", "pipe", "pipe"]
@@ -7919,19 +8537,19 @@ function findGitRoot(start) {
   }
 }
 function detectWorkspace(cwd = findGitRoot(process.cwd())) {
-  const pnpmWs = (0, import_path4.join)(cwd, "pnpm-workspace.yaml");
-  if ((0, import_fs4.existsSync)(pnpmWs)) {
-    const content = (0, import_fs4.readFileSync)(pnpmWs, "utf-8");
+  const pnpmWs = (0, import_path6.join)(cwd, "pnpm-workspace.yaml");
+  if ((0, import_fs6.existsSync)(pnpmWs)) {
+    const content = (0, import_fs6.readFileSync)(pnpmWs, "utf-8");
     const match = content.match(/packages:\s*\n((?:\s+-\s+.+\n?)*)/);
     if (match) {
       const packages = match[1].split("\n").map((l) => l.replace(/^\s+-\s+/, "").replace(/["']/g, "").trim()).filter(Boolean);
       return { type: "pnpm", packages, root: cwd };
     }
   }
-  const lerna = (0, import_path4.join)(cwd, "lerna.json");
-  if ((0, import_fs4.existsSync)(lerna)) {
+  const lerna = (0, import_path6.join)(cwd, "lerna.json");
+  if ((0, import_fs6.existsSync)(lerna)) {
     try {
-      const config2 = JSON.parse((0, import_fs4.readFileSync)(lerna, "utf-8"));
+      const config2 = JSON.parse((0, import_fs6.readFileSync)(lerna, "utf-8"));
       return {
         type: "lerna",
         packages: config2.packages ?? ["packages/*"],
@@ -7940,18 +8558,18 @@ function detectWorkspace(cwd = findGitRoot(process.cwd())) {
     } catch {
     }
   }
-  if ((0, import_fs4.existsSync)((0, import_path4.join)(cwd, "nx.json"))) {
+  if ((0, import_fs6.existsSync)((0, import_path6.join)(cwd, "nx.json"))) {
     return {
       type: "nx",
       packages: ["packages/*", "apps/*", "libs/*"],
       root: cwd
     };
   }
-  if ((0, import_fs4.existsSync)((0, import_path4.join)(cwd, "turbo.json"))) {
-    const pkgPath2 = (0, import_path4.join)(cwd, "package.json");
-    if ((0, import_fs4.existsSync)(pkgPath2)) {
+  if ((0, import_fs6.existsSync)((0, import_path6.join)(cwd, "turbo.json"))) {
+    const pkgPath2 = (0, import_path6.join)(cwd, "package.json");
+    if ((0, import_fs6.existsSync)(pkgPath2)) {
       try {
-        const config2 = JSON.parse((0, import_fs4.readFileSync)(pkgPath2, "utf-8"));
+        const config2 = JSON.parse((0, import_fs6.readFileSync)(pkgPath2, "utf-8"));
         if (config2.workspaces) {
           const ws = Array.isArray(config2.workspaces) ? config2.workspaces : config2.workspaces.packages ?? [];
           return { type: "turbo", packages: ws, root: cwd };
@@ -7960,10 +8578,10 @@ function detectWorkspace(cwd = findGitRoot(process.cwd())) {
       }
     }
   }
-  const pkgPath = (0, import_path4.join)(cwd, "package.json");
-  if ((0, import_fs4.existsSync)(pkgPath)) {
+  const pkgPath = (0, import_path6.join)(cwd, "package.json");
+  if ((0, import_fs6.existsSync)(pkgPath)) {
     try {
-      const config2 = JSON.parse((0, import_fs4.readFileSync)(pkgPath, "utf-8"));
+      const config2 = JSON.parse((0, import_fs6.readFileSync)(pkgPath, "utf-8"));
       if (config2.workspaces) {
         const ws = Array.isArray(config2.workspaces) ? config2.workspaces : config2.workspaces.packages ?? [];
         return { type: "npm", packages: ws, root: cwd };
@@ -8006,8 +8624,8 @@ function matchGlobPattern(rel, pattern) {
   return null;
 }
 function getPackageForFile(filePath, workspace) {
-  const absPath = filePath.startsWith("/") ? filePath : (0, import_path4.join)(workspace.root, filePath);
-  const rel = (0, import_path4.relative)(workspace.root, absPath);
+  const absPath = filePath.startsWith("/") ? filePath : (0, import_path6.join)(workspace.root, filePath);
+  const rel = (0, import_path6.relative)(workspace.root, absPath);
   for (const pattern of workspace.packages) {
     const packageName = matchGlobPattern(rel, pattern);
     if (packageName) return packageName;
@@ -8017,7 +8635,7 @@ function getPackageForFile(filePath, workspace) {
 function autoDetectScope(stagedFiles, workspace) {
   const packages = /* @__PURE__ */ new Set();
   for (const file of stagedFiles) {
-    const filePath = file.startsWith("/") ? file : (0, import_path4.join)(workspace.root, file);
+    const filePath = file.startsWith("/") ? file : (0, import_path6.join)(workspace.root, file);
     const pkg = getPackageForFile(filePath, workspace);
     if (pkg) packages.add(pkg);
   }
@@ -8030,477 +8648,126 @@ function autoDetectScope(stagedFiles, workspace) {
   }
   return null;
 }
-var import_child_process3, import_fs4, import_path4;
+var import_child_process5, import_fs6, import_path6;
 var init_monorepo = __esm({
   "src/monorepo.ts"() {
     "use strict";
-    import_child_process3 = require("child_process");
-    import_fs4 = require("fs");
-    import_path4 = require("path");
+    import_child_process5 = require("child_process");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
   }
 });
 
-// src/commands/login.ts
-var login_exports = {};
-__export(login_exports, {
-  runLogin: () => runLogin
-});
-function openBrowser(url) {
-  try {
-    if ((0, import_os3.platform)() === "darwin") {
-      (0, import_child_process4.execFileSync)("open", [url], { stdio: "pipe" });
-      return true;
-    }
-    if ((0, import_os3.platform)() === "linux") {
-      (0, import_child_process4.execFileSync)("xdg-open", [url], { stdio: "pipe" });
-      return true;
-    }
-    if ((0, import_os3.platform)() === "win32") {
-      (0, import_child_process4.execFileSync)("cmd", ["/c", "start", "", url], { stdio: "pipe" });
-      return true;
-    }
-  } catch {
-  }
-  return false;
+// src/commands/changeset.ts
+var changeset_exports = {};
+__export(changeset_exports, {
+  changeset: () => changeset,
+  formatChangesetFile: () => formatChangesetFile,
+  generateSlug: () => generateSlug,
+  mapFilesToPackages: () => mapFilesToPackages
+});
+function generateSlug() {
+  const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+  return `${pick(ADJECTIVES)}-${pick(ANIMALS)}-${pick(VERBS)}`;
 }
-async function runLogin() {
-  const codeRes = await fetch(`${API_URL}/api/auth/device/code`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ client_id: CLIENT_ID })
-  });
-  if (!codeRes.ok) {
-    const err = await codeRes.json().catch(() => ({ error: codeRes.statusText }));
-    throw new Error(err.error ?? "Failed to start device flow");
-  }
-  const codeData = await codeRes.json();
-  const { device_code, user_code, verification_uri_complete, interval = 5 } = codeData;
-  if (!device_code || !user_code) {
-    throw new Error("Server did not return device codes");
-  }
-  console.log("Opening browser to sign in...");
-  console.log("");
-  console.log(`  Your code: ${user_code}`);
-  console.log("");
-  const authUrl = verification_uri_complete ?? `${DASHBOARD_URL}/device?user_code=${encodeURIComponent(user_code)}`;
-  const opened = openBrowser(authUrl);
-  if (!opened) {
-    console.log("Could not open browser. Please visit:");
-    console.log(authUrl);
-    console.log("");
-  }
-  let frame = 0;
-  const spinner = setInterval(() => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1e3);
-    process.stderr.write(
-      `\r${SPINNER_FRAMES[frame++ % SPINNER_FRAMES.length]} Waiting for authorization... (${elapsed}s)`
-    );
-  }, 80);
-  let pollingInterval = interval * 1e3;
-  const startTime = Date.now();
-  try {
-    while (Date.now() - startTime < DEVICE_FLOW_TIMEOUT) {
-      await new Promise((r) => setTimeout(r, pollingInterval));
+function mapFilesToPackages(files, workspace) {
+  const dirToName = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const dirName = getPackageForFile(file, workspace);
+    if (!dirName || dirToName.has(dirName)) continue;
+    for (const pattern of workspace.packages) {
+      const hasGlob = /\*/.test(pattern);
+      const dir = pattern.replace(/\/?\*\*?$/, "").replace(/\/$/, "");
+      const pkgJsonPath = hasGlob ? (0, import_path7.join)(workspace.root, dir, dirName, "package.json") : (0, import_path7.join)(workspace.root, pattern.replace(/\/$/, ""), "package.json");
       try {
-        const tokenRes = await fetch(`${API_URL}/api/auth/device/token`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-            device_code,
-            client_id: CLIENT_ID
-          })
-        });
-        const tokenData = await tokenRes.json();
-        if (tokenData.access_token) {
-          saveApiKey(tokenData.access_token);
-          process.stderr.write("\r\x1B[2K");
-          console.log("Successfully logged in!");
-          return;
-        }
-        if (tokenData.error) {
-          switch (tokenData.error) {
-            case "authorization_pending":
-              break;
-            // continue polling
-            case "slow_down":
-              pollingInterval += 5e3;
-              break;
-            case "access_denied":
-              process.stderr.write("\r\x1B[2K");
-              console.error("Authorization was denied.");
-              process.exit(1);
-              break;
-            case "expired_token":
-              process.stderr.write("\r\x1B[2K");
-              console.error("Device code expired. Please try again.");
-              process.exit(1);
-              break;
-            default:
-              process.stderr.write("\r\x1B[2K");
-              console.error(`Error: ${tokenData.error_description ?? tokenData.error}`);
-              process.exit(1);
-          }
-        }
+        const pkg = JSON.parse((0, import_fs7.readFileSync)(pkgJsonPath, "utf-8"));
+        dirToName.set(dirName, pkg.name ?? dirName);
+        break;
       } catch {
       }
     }
-    process.stderr.write("\r\x1B[2K");
-    console.error("Login timed out. Please try again.");
-    process.exit(1);
-  } finally {
-    clearInterval(spinner);
+    if (!dirToName.has(dirName)) {
+      dirToName.set(dirName, dirName);
+    }
   }
+  return dirToName;
 }
-var import_child_process4, import_os3, API_URL, DASHBOARD_URL, CLIENT_ID, SPINNER_FRAMES;
-var init_login = __esm({
-  "src/commands/login.ts"() {
-    "use strict";
-    import_child_process4 = require("child_process");
-    import_os3 = require("os");
-    init_config();
-    init_dist();
-    API_URL = process.env.QC_API_URL ?? DEFAULT_API_URL;
-    DASHBOARD_URL = "https://app.quikcommit.dev";
-    CLIENT_ID = "qc-cli";
-    SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  }
-});
+function formatChangesetFile(packages, summary) {
+  const frontmatter = packages.map((p) => `"${p.name}": ${p.bump}`).join("\n");
+  return `---
+${frontmatter}
+---
 
-// src/commands/logout.ts
-var logout_exports = {};
-__export(logout_exports, {
-  runLogout: () => runLogout
-});
-function runLogout() {
-  clearApiKey();
-  console.log("Logged out. Credentials cleared.");
+${summary}
+`;
 }
-var init_logout = __esm({
-  "src/commands/logout.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
-// src/commands/status.ts
-var status_exports = {};
-__export(status_exports, {
-  runStatus: () => runStatus
-});
-async function runStatus(apiKeyFlag) {
-  const apiKey = apiKeyFlag ?? getApiKey();
+async function prompt(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+async function changeset(options) {
+  const base = options.base ?? "main";
+  const apiKey = getApiKey();
   if (!apiKey) {
-    console.log("Not logged in. Run `qc login` to authenticate.");
-    return;
+    console.error("Error: Not authenticated. Run `qc login` first.");
+    process.exit(1);
   }
-  console.log("Logged in: yes");
-  console.log(`  API key: ...${apiKey.slice(-4)}`);
-  const client = new ApiClient({ apiKey });
-  const usage = await client.getUsage();
-  if (usage) {
-    console.log(`Plan: ${usage.plan}`);
-    console.log(`Usage: ${usage.commit_count}/${usage.limit} commits this period`);
-    console.log(`Remaining: ${usage.remaining}`);
-  } else {
-    console.log("Usage: (unable to fetch)");
+  const { detectWorkspace: detectWorkspace2 } = await Promise.resolve().then(() => (init_monorepo(), monorepo_exports));
+  const workspace = detectWorkspace2();
+  if (!workspace) {
+    console.error(
+      "No workspace packages found. Is this a pnpm monorepo?"
+    );
+    process.exit(1);
   }
-}
-var init_status = __esm({
-  "src/commands/status.ts"() {
-    "use strict";
-    init_config();
-    init_api();
+  const changedFiles = getChangedFilesSince(base);
+  if (changedFiles.length === 0) {
+    console.error(`No changes detected vs ${base}.`);
+    process.exit(1);
   }
-});
-
-// src/commands/pr.ts
-var pr_exports = {};
-__export(pr_exports, {
-  pr: () => pr
-});
-function findPullRequestTemplate(gitRoot) {
-  const fileCandidates = [
-    (0, import_path5.join)(gitRoot, ".github", "pull_request_template.md"),
-    (0, import_path5.join)(gitRoot, ".github", "PULL_REQUEST_TEMPLATE.md"),
-    (0, import_path5.join)(gitRoot, "pull_request_template.md")
-  ];
-  for (const p of fileCandidates) {
+  const packageMap = mapFilesToPackages(changedFiles, workspace);
+  const packageNames = Array.from(packageMap.values());
+  if (packageNames.length === 0) {
+    console.error("No workspace packages detected in changed files.");
+    process.exit(1);
+  }
+  const commits = getOnlineLog(base);
+  const diff = getFullDiff(base);
+  const commitCount = commits.split("\n").filter(Boolean).length;
+  console.error(
+    `Analyzing changes vs ${base}... ${commitCount} commit(s), ${packageNames.length} package(s) changed`
+  );
+  const client = new ApiClient({ apiKey });
+  let result;
+  const msg = (e) => e instanceof Error ? e.message : String(e);
+  const isTransient = (m) => /invalid json|no changeset|unexpected response|ai worker|timeout|502|503|504/i.test(m);
+  let attempts = 0;
+  while (true) {
     try {
-      if ((0, import_fs5.existsSync)(p) && (0, import_fs5.statSync)(p).isFile()) {
-        return { path: p, content: (0, import_fs5.readFileSync)(p, "utf-8") };
+      result = await client.generateChangeset({
+        diff,
+        packages: packageNames,
+        commits,
+        model: options.model
+      });
+      break;
+    } catch (err) {
+      const m = msg(err);
+      if (!isTransient(m)) {
+        console.error(m);
+        process.exit(1);
       }
-    } catch {
+      if (attempts === 0) {
+        attempts++;
+        continue;
+      }
+      console.error(m);
+      process.exit(1);
     }
   }
-  const multiDir = (0, import_path5.join)(gitRoot, ".github", "PULL_REQUEST_TEMPLATE");
-  try {
-    if ((0, import_fs5.existsSync)(multiDir) && (0, import_fs5.statSync)(multiDir).isDirectory()) {
-      const names = (0, import_fs5.readdirSync)(multiDir).filter((f) => f.toLowerCase().endsWith(".md")).sort();
-      if (names.length > 0) {
-        const p = (0, import_path5.join)(multiDir, names[0]);
-        if ((0, import_fs5.statSync)(p).isFile()) {
-          return { path: p, content: (0, import_fs5.readFileSync)(p, "utf-8") };
-        }
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-async function pr(options) {
-  const base = options.base ?? "main";
-  const commits = getBranchCommits(base);
-  const diffStat = getDiffStat(base);
-  const gitRoot = getGitRoot();
-  const templateHit = findPullRequestTemplate(gitRoot);
-  let prTemplate;
-  if (templateHit) {
-    prTemplate = templateHit.content.substring(0, 16 * 1024);
-    console.error(`[qc] Using PR template from ${(0, import_path5.relative)(gitRoot, templateHit.path)}`);
-  }
-  const currentBranch = getCurrentBranch().slice(0, MAX_PR_CURRENT_BRANCH_CHARS);
-  if (commits.length === 0) {
-    console.error(`No commits found on this branch vs ${base}`);
-    process.exit(1);
-  }
-  const commitlintRules = await detectCommitlintRules();
-  console.error(`Generating PR description from ${commits.length} commits...`);
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    console.error("Error: Not authenticated. Run `qc login` first.");
-    process.exit(1);
-  }
-  const client = new ApiClient({ apiKey });
-  const result = await client.generatePR(
-    {
-      commits,
-      diff_stat: diffStat,
-      base_branch: base,
-      current_branch: currentBranch,
-      pr_template: prTemplate,
-      rules: commitlintRules
-    },
-    options.model
-  );
-  const trimmedTitle = result.title.trim();
-  if (trimmedTitle) {
-    console.log(`
-Title: ${trimmedTitle}
-`);
-  }
-  console.log(result.message + "\n");
-  if (options.create) {
-    try {
-      const prTitle = trimmedTitle || result.message.split("\n").find((l) => l.trim()) || result.message.substring(0, 72).trim();
-      (0, import_child_process5.execFileSync)("gh", ["pr", "create", "--title", prTitle, "--body", result.message], {
-        stdio: "inherit"
-      });
-    } catch {
-      console.error("Error: `gh` CLI not found or failed. Install from https://cli.github.com/");
-      process.exit(1);
-    }
-  }
-}
-var import_child_process5, import_fs5, import_path5;
-var init_pr = __esm({
-  "src/commands/pr.ts"() {
-    "use strict";
-    import_child_process5 = require("child_process");
-    import_fs5 = require("fs");
-    import_path5 = require("path");
-    init_dist();
-    init_config();
-    init_api();
-    init_commitlint();
-    init_git();
-  }
-});
-
-// src/commands/changelog.ts
-var changelog_exports = {};
-__export(changelog_exports, {
-  changelog: () => changelog
-});
-function parseCommitType(subject) {
-  const match = subject.match(CONVENTIONAL_TYPE_RE);
-  return match ? match[1].toLowerCase() : "chore";
-}
-function groupCommitsByType(commits) {
-  const byType = {};
-  for (const { subject } of commits) {
-    const type = parseCommitType(subject);
-    if (!byType[type]) byType[type] = [];
-    byType[type].push(subject);
-  }
-  return byType;
-}
-async function changelog(options) {
-  const fromRef = options.from ?? getLatestTag();
-  const toRef = options.to ?? "HEAD";
-  if (!fromRef) {
-    console.error("Error: No git tag found. Use --from <ref> to specify a starting point.");
-    process.exit(1);
-  }
-  const commits = getCommitsSince(fromRef, toRef);
-  if (commits.length === 0) {
-    console.error(`No commits found between ${fromRef} and ${toRef}`);
-    process.exit(1);
-  }
-  const commitsByType = groupCommitsByType(commits);
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    console.error("Error: Not authenticated. Run `qc login` first.");
-    process.exit(1);
-  }
-  const client = new ApiClient({ apiKey });
-  const result = await client.generateChangelog(
-    {
-      commits_by_type: commitsByType,
-      from_tag: fromRef,
-      to_ref: toRef
-    },
-    options.model
-  );
-  const version = options.version ?? (/^v?\d/.test(toRef) && toRef !== "HEAD" ? toRef.replace(/^v/, "") : null) ?? `${fromRef.replace(/^v/, "")}-next`;
-  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const header = `## [${version}] - ${date}
-
-`;
-  const changelogEntry = header + result.message;
-  if (options.write) {
-    const path = (0, import_path6.join)(getGitRoot(), "CHANGELOG.md");
-    const existing = (0, import_fs6.existsSync)(path) ? (0, import_fs6.readFileSync)(path, "utf-8") : "";
-    const newContent = changelogEntry + (existing ? "\n\n" + existing : "");
-    (0, import_fs6.writeFileSync)(path, newContent);
-    console.error(`Wrote to ${path}`);
-  } else {
-    console.log(changelogEntry);
-  }
-}
-var import_fs6, import_path6, CONVENTIONAL_TYPE_RE;
-var init_changelog = __esm({
-  "src/commands/changelog.ts"() {
-    "use strict";
-    import_fs6 = require("fs");
-    import_path6 = require("path");
-    init_config();
-    init_api();
-    init_git();
-    CONVENTIONAL_TYPE_RE = /^(feat|fix|docs|style|refactor|perf|test|chore)(\([^)]+\))?!?:\s+/i;
-  }
-});
-
-// src/commands/changeset.ts
-var changeset_exports = {};
-__export(changeset_exports, {
-  changeset: () => changeset,
-  formatChangesetFile: () => formatChangesetFile,
-  generateSlug: () => generateSlug,
-  mapFilesToPackages: () => mapFilesToPackages
-});
-function generateSlug() {
-  const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
-  return `${pick(ADJECTIVES)}-${pick(ANIMALS)}-${pick(VERBS)}`;
-}
-function mapFilesToPackages(files, workspace) {
-  const dirToName = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const dirName = getPackageForFile(file, workspace);
-    if (!dirName || dirToName.has(dirName)) continue;
-    for (const pattern of workspace.packages) {
-      const hasGlob = /\*/.test(pattern);
-      const dir = pattern.replace(/\/?\*\*?$/, "").replace(/\/$/, "");
-      const pkgJsonPath = hasGlob ? (0, import_path7.join)(workspace.root, dir, dirName, "package.json") : (0, import_path7.join)(workspace.root, pattern.replace(/\/$/, ""), "package.json");
-      try {
-        const pkg = JSON.parse((0, import_fs7.readFileSync)(pkgJsonPath, "utf-8"));
-        dirToName.set(dirName, pkg.name ?? dirName);
-        break;
-      } catch {
-      }
-    }
-    if (!dirToName.has(dirName)) {
-      dirToName.set(dirName, dirName);
-    }
-  }
-  return dirToName;
-}
-function formatChangesetFile(packages, summary) {
-  const frontmatter = packages.map((p) => `"${p.name}": ${p.bump}`).join("\n");
-  return `---
-${frontmatter}
----
-
-${summary}
-`;
-}
-async function prompt(rl, question) {
-  return new Promise((resolve) => rl.question(question, resolve));
-}
-async function changeset(options) {
-  const base = options.base ?? "main";
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    console.error("Error: Not authenticated. Run `qc login` first.");
-    process.exit(1);
-  }
-  const { detectWorkspace: detectWorkspace2 } = await Promise.resolve().then(() => (init_monorepo(), monorepo_exports));
-  const workspace = detectWorkspace2();
-  if (!workspace) {
-    console.error(
-      "No workspace packages found. Is this a pnpm monorepo?"
-    );
-    process.exit(1);
-  }
-  const changedFiles = getChangedFilesSince(base);
-  if (changedFiles.length === 0) {
-    console.error(`No changes detected vs ${base}.`);
-    process.exit(1);
-  }
-  const packageMap = mapFilesToPackages(changedFiles, workspace);
-  const packageNames = Array.from(packageMap.values());
-  if (packageNames.length === 0) {
-    console.error("No workspace packages detected in changed files.");
-    process.exit(1);
-  }
-  const commits = getOnlineLog(base);
-  const diff = getFullDiff(base);
-  const commitCount = commits.split("\n").filter(Boolean).length;
-  console.error(
-    `Analyzing changes vs ${base}... ${commitCount} commit(s), ${packageNames.length} package(s) changed`
-  );
-  const client = new ApiClient({ apiKey });
-  let result;
-  const msg = (e) => e instanceof Error ? e.message : String(e);
-  const isTransient = (m) => /invalid json|no changeset|unexpected response|ai worker|timeout|502|503|504/i.test(m);
-  let attempts = 0;
-  while (true) {
-    try {
-      result = await client.generateChangeset({
-        diff,
-        packages: packageNames,
-        commits,
-        model: options.model
-      });
-      break;
-    } catch (err) {
-      const m = msg(err);
-      if (!isTransient(m)) {
-        console.error(m);
-        process.exit(1);
-      }
-      if (attempts === 0) {
-        attempts++;
-        continue;
-      }
-      console.error(m);
-      process.exit(1);
-    }
-  }
-  const resultNames = new Set(result.packages.map((p) => p.name));
-  for (const name of packageNames) {
-    if (!resultNames.has(name)) {
-      result.packages.push({ name, bump: "patch", reason: "included in changeset" });
+  const resultNames = new Set(result.packages.map((p) => p.name));
+  for (const name of packageNames) {
+    if (!resultNames.has(name)) {
+      result.packages.push({ name, bump: "patch", reason: "included in changeset" });
     }
   }
   console.log("");
@@ -8697,6 +8964,1561 @@ var init_changeset = __esm({
   }
 });
 
+// src/branch-rescue.ts
+function rescueCommits(opts) {
+  const upstream = getUpstreamRef(opts.currentBranch);
+  if (!upstream) {
+    throw new Error(
+      `No upstream tracking branch for '${opts.currentBranch}'. Push it first or use \`qc branch\` manually.`
+    );
+  }
+  const headSha = getHeadSha();
+  const stashed = stashPushIfDirty(`qc-rescue-${opts.newBranch}`);
+  try {
+    createBranch(opts.newBranch, headSha);
+  } catch (err) {
+    if (stashed) {
+      try {
+        stashPop();
+      } catch {
+      }
+    }
+    throw err;
+  }
+  try {
+    resetHard(upstream);
+  } catch (err) {
+    try {
+      deleteBranch(opts.newBranch);
+    } catch {
+    }
+    if (stashed) {
+      try {
+        stashPop();
+      } catch {
+      }
+    }
+    throw new Error(
+      `Rescue aborted: failed to reset ${opts.currentBranch} to upstream. Your repo state has been restored. Original error: ${err?.message ?? String(err)}`
+    );
+  }
+  try {
+    checkoutBranch(opts.newBranch);
+  } catch (err) {
+    try {
+      resetHard(headSha);
+    } catch {
+    }
+    if (stashed) {
+      try {
+        stashPop();
+      } catch {
+      }
+    }
+    throw err;
+  }
+  if (stashed) {
+    try {
+      stashPop();
+    } catch (err) {
+      throw new Error(
+        `Stash conflict during recovery. Your changes are preserved in the stash entry. Resolve manually with \`git stash pop\` then \`git stash drop\` after resolving conflicts.
+Original error: ${err?.message ?? err}`
+      );
+    }
+  }
+  return {
+    newBranch: opts.newBranch,
+    stashed,
+    upstreamRef: upstream,
+    movedFromSha: headSha
+  };
+}
+var init_branch_rescue = __esm({
+  "src/branch-rescue.ts"() {
+    "use strict";
+    init_git();
+  }
+});
+
+// src/branch-detect.ts
+function matchGlob(name, pattern) {
+  const n = name.toLowerCase();
+  const p = pattern.toLowerCase();
+  if (!p.includes("*")) return n === p;
+  const escaped = p.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const withDoubleStar = escaped.replace(/\*\*/g, "\0DOUBLE_STAR\0");
+  const withSingleStar = withDoubleStar.replace(/\*/g, "[^/]*");
+  const final = withSingleStar.replace(/\x00DOUBLE_STAR\x00/g, ".*");
+  const rx = new RegExp("^" + final + "$");
+  return rx.test(n);
+}
+function isProtectedBranch(branch, protectedList) {
+  if (!protectedList || protectedList.length === 0) return false;
+  return protectedList.some((p) => matchGlob(branch, p));
+}
+function resolveProtectedBranches(opts) {
+  const set = /* @__PURE__ */ new Set();
+  if (opts.configList && opts.configList.length > 0) {
+    for (const b of opts.configList) set.add(b);
+  } else {
+    for (const b of HARDCODED_PROTECTED) set.add(b);
+  }
+  if (opts.detectDefault && opts.defaultBranch) {
+    set.add(opts.defaultBranch);
+  }
+  return Array.from(set);
+}
+var HARDCODED_PROTECTED;
+var init_branch_detect = __esm({
+  "src/branch-detect.ts"() {
+    "use strict";
+    HARDCODED_PROTECTED = ["main", "master", "develop", "trunk"];
+  }
+});
+
+// src/protected-branch-guard.ts
+function shouldRunGuard(opts) {
+  if (opts.allowProtected) return false;
+  if (opts.hookMode) return false;
+  if (!opts.isTTY) return false;
+  return true;
+}
+function detectProtectedBranchState(opts) {
+  const branch = getCurrentBranch();
+  const protectedList = resolveProtectedBranches({
+    configList: opts.protectedBranches,
+    detectDefault: opts.detectDefault !== false,
+    defaultBranch: getDefaultBranch()
+  });
+  const protectedBranch = isProtectedBranch(branch, protectedList);
+  if (!protectedBranch) {
+    return { isProtected: false, branch, commitsAhead: 0, mode: "none" };
+  }
+  const commitsAhead = getCommitsAheadOfUpstream(branch);
+  const mode = commitsAhead > 0 ? "rescue" : "uncommitted";
+  return { isProtected: true, branch, commitsAhead, mode };
+}
+var init_protected_branch_guard = __esm({
+  "src/protected-branch-guard.ts"() {
+    "use strict";
+    init_branch_detect();
+    init_git();
+  }
+});
+
+// src/branch-name.ts
+function sanitizeBranchName(input) {
+  if (!input) return null;
+  let s = input.toLowerCase().trim();
+  s = s.replace(/[\s_]+/g, "-");
+  s = s.replace(/[^a-z0-9/-]/g, "");
+  s = s.replace(/-+/g, "-").replace(/\/+/g, "/");
+  s = s.replace(/^[-/]+|[-/]+$/g, "");
+  if (!s.includes("/")) return null;
+  if (s.length > MAX_BRANCH_NAME_LENGTH) {
+    const parts = s.split("/");
+    const type = parts[0] ?? "";
+    const slugBudget = Math.min(MAX_BRANCH_NAME_LENGTH - type.length - 1, 52);
+    if (slugBudget < 2) return null;
+    s = `${type}/${parts.slice(1).join("/").slice(0, slugBudget).replace(/-+$/g, "")}`;
+  }
+  return validateBranchName(s) ? s : null;
+}
+function ensureUniqueName(name, exists) {
+  if (!exists(name)) return name;
+  for (let i = 2; i <= 100; i++) {
+    const candidate = `${name}-${i}`;
+    if (!exists(candidate)) return candidate;
+  }
+  throw new Error(`Could not find a unique name for ${name} after 100 attempts`);
+}
+function finalizeBranchName(raw, exists, options = {}) {
+  let candidate = raw;
+  if (!validateBranchName(candidate)) {
+    const s = sanitizeBranchName(candidate);
+    if (!s) {
+      throw new Error(`Generated invalid branch name and could not sanitize: ${raw}`);
+    }
+    candidate = s;
+  }
+  if (options.skipUniqueness) {
+    return candidate;
+  }
+  return ensureUniqueName(candidate, exists);
+}
+var init_branch_name = __esm({
+  "src/branch-name.ts"() {
+    "use strict";
+    init_dist();
+  }
+});
+
+// ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports2, module2) {
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module2.exports = createColors();
+    module2.exports.createColors = createColors;
+  }
+});
+
+// src/ui.ts
+function hasCliNoColor() {
+  try {
+    return process.argv.slice(2).includes("--no-color");
+  } catch {
+    return false;
+  }
+}
+function getTerminalWidth() {
+  return process.stderr.columns ?? process.stdout.columns ?? 80;
+}
+function createUI(options) {
+  const isColor = options.isTTY && !options.noColor;
+  const wrap = (fn) => (s) => isColor ? fn(s) : s;
+  const format = {
+    step: (msg) => `${isColor ? import_picocolors.default.dim("\u203A") : "\u203A"} ${isColor ? import_picocolors.default.dim(msg) : msg}`,
+    success: (msg) => `${isColor ? import_picocolors.default.green("\u2713") : "\u2713"} ${msg}`,
+    error: (msg) => `${isColor ? import_picocolors.default.red("\u2717") : "\u2717"} ${msg}`,
+    dim: wrap(import_picocolors.default.dim),
+    bold: wrap(import_picocolors.default.bold),
+    commitType: wrap(import_picocolors.default.cyan),
+    commitScope: wrap(import_picocolors.default.yellow),
+    accent: wrap(import_picocolors.default.magenta)
+  };
+  function createSpinner(message, write = (s) => process.stderr.write(s)) {
+    let frame = 0;
+    let interval = null;
+    return {
+      start() {
+        if (interval) return;
+        if (!options.isTTY) return;
+        interval = setInterval(() => {
+          const f = SPINNER_FRAMES2[frame++ % SPINNER_FRAMES2.length];
+          write(`\r${format.step(message)} ${isColor ? import_picocolors.default.cyan(f) : f}`);
+        }, 80);
+      },
+      stop(finalMessage) {
+        if (interval) {
+          clearInterval(interval);
+          interval = null;
+        }
+        if (options.isTTY) {
+          write("\r\x1B[2K");
+        }
+        if (finalMessage) {
+          write(finalMessage + "\n");
+        }
+      }
+    };
+  }
+  const log = {
+    step: (msg) => process.stderr.write(format.step(msg) + "\n"),
+    success: (msg) => process.stderr.write(format.success(msg) + "\n"),
+    error: (msg) => process.stderr.write(format.error(msg) + "\n"),
+    dim: (msg) => process.stderr.write(format.dim(msg) + "\n")
+  };
+  return { isColor, format, spinner: createSpinner, log };
+}
+function getUI() {
+  if (!_defaultUI) {
+    _defaultUI = createUI({
+      isTTY: !!process.stderr.isTTY,
+      noColor: !!process.env.NO_COLOR || hasCliNoColor()
+    });
+  }
+  return _defaultUI;
+}
+var import_picocolors, SPINNER_FRAMES2, _defaultUI, ui;
+var init_ui = __esm({
+  "src/ui.ts"() {
+    "use strict";
+    import_picocolors = __toESM(require_picocolors());
+    SPINNER_FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    ui = new Proxy({}, {
+      get(_target, prop) {
+        return getUI()[prop];
+      }
+    });
+  }
+});
+
+// src/ui-rich.ts
+function splitCommitForBox(message) {
+  const firstLine = message.split("\n")[0] ?? "";
+  const m = firstLine.match(HEADER_RX);
+  if (!m) return { type: null, scope: null, subject: firstLine, breaking: false };
+  return {
+    type: m[1] ?? null,
+    scope: m[2] ?? null,
+    breaking: m[3] === "!",
+    subject: m[4] ?? ""
+  };
+}
+function renderFileTree(files, maxFiles) {
+  if (files.length === 0) return "";
+  const lines = [];
+  const display = files.slice(0, maxFiles);
+  const overflow = Math.max(0, files.length - maxFiles);
+  for (let i = 0; i < display.length; i++) {
+    const isLast = i === display.length - 1 && overflow === 0;
+    const connector = isLast ? "\u2514\u2500" : "\u251C\u2500";
+    lines.push(`    ${connector} ${display[i]}`);
+  }
+  if (overflow > 0) {
+    lines.push(`    \u2514\u2500 +${overflow} more files`);
+  }
+  return lines.join("\n");
+}
+function wrapLine(text, width) {
+  if (text.length <= width) return [text];
+  const result = [];
+  let remaining = text;
+  while (remaining.length > width) {
+    let breakAt = remaining.lastIndexOf(" ", width);
+    if (breakAt < width / 2) breakAt = width;
+    result.push(remaining.slice(0, breakAt));
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  if (remaining) result.push(remaining);
+  return result;
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function boxedLine(content, innerWidth, isColor) {
+  const visibleLen = stripAnsi(content).length;
+  const padding = " ".repeat(Math.max(0, innerWidth - visibleLen));
+  const border = isColor ? import_picocolors2.default.dim("\u2502") : "\u2502";
+  return `  ${border}  ${content}${padding}  ${border}`;
+}
+function renderBoxedCommit(header, body, opts) {
+  if (opts.width < MIN_BOX_WIDTH) {
+    const lines2 = [header.split("\n")[0] ?? header];
+    if (body) lines2.push("", body);
+    return lines2.join("\n");
+  }
+  const innerWidth = opts.width - 8;
+  const horiz = opts.width - 2;
+  const top = "  " + (opts.isColor ? import_picocolors2.default.dim("\u256D" + "\u2500".repeat(horiz) + "\u256E") : "\u256D" + "\u2500".repeat(horiz) + "\u256E");
+  const bottom = "  " + (opts.isColor ? import_picocolors2.default.dim("\u2570" + "\u2500".repeat(horiz) + "\u256F") : "\u2570" + "\u2500".repeat(horiz) + "\u256F");
+  const parsed = splitCommitForBox(header);
+  let firstLineStyled;
+  if (parsed.type && parsed.scope) {
+    const bare = `${parsed.type}(${parsed.scope})${parsed.breaking ? "!" : ""}: ${parsed.subject}`;
+    firstLineStyled = opts.isColor ? `${import_picocolors2.default.bold(import_picocolors2.default.cyan(parsed.type))}(${import_picocolors2.default.bold(import_picocolors2.default.yellow(parsed.scope))})${parsed.breaking ? import_picocolors2.default.bold(import_picocolors2.default.red("!")) : ""}: ${parsed.subject}` : bare;
+  } else if (parsed.type) {
+    const bare = `${parsed.type}${parsed.breaking ? "!" : ""}: ${parsed.subject}`;
+    firstLineStyled = opts.isColor ? `${import_picocolors2.default.bold(import_picocolors2.default.cyan(parsed.type))}${parsed.breaking ? import_picocolors2.default.bold(import_picocolors2.default.red("!")) : ""}: ${parsed.subject}` : bare;
+  } else {
+    firstLineStyled = header.split("\n")[0] ?? header;
+  }
+  const lines = [];
+  const headerParts = wrapLine(firstLineStyled, innerWidth);
+  for (let i = 0; i < headerParts.length; i++) {
+    const indent = i === 0 ? "" : "    ";
+    lines.push(boxedLine(indent + (headerParts[i] ?? ""), innerWidth, opts.isColor));
+  }
+  if (body) {
+    lines.push(boxedLine("", innerWidth, opts.isColor));
+    for (const bline of body.split("\n")) {
+      const trimmed = bline.trim();
+      if (!trimmed) continue;
+      const rendered = trimmed.replace(/^[-*]\s+/, opts.isColor ? `${import_picocolors2.default.green("\u2022")} ` : "\u2022 ");
+      const wrapped = wrapLine(rendered, innerWidth);
+      for (let i = 0; i < wrapped.length; i++) {
+        lines.push(boxedLine((i === 0 ? "" : "  ") + (wrapped[i] ?? ""), innerWidth, opts.isColor));
+      }
+    }
+  }
+  return [top, ...lines, bottom].join("\n");
+}
+function renderStatsLine(stats, isColor) {
+  const parts = [];
+  parts.push(`${stats.files} files`);
+  parts.push(`+${stats.additions} \u2212${stats.deletions}`);
+  if (stats.tokens !== void 0) parts.push(`${stats.tokens} tokens`);
+  const text = parts.join(" \xB7 ");
+  return isColor ? `    ${import_picocolors2.default.dim(text)}` : `    ${text}`;
+}
+function shouldUseRichOutput(opts) {
+  if (!opts.isTTY) return false;
+  if (opts.noColor) return false;
+  if (opts.style !== "rich") return false;
+  if (opts.width < MIN_BOX_WIDTH) return false;
+  return true;
+}
+var import_picocolors2, HEADER_RX, MIN_BOX_WIDTH;
+var init_ui_rich = __esm({
+  "src/ui-rich.ts"() {
+    "use strict";
+    import_picocolors2 = __toESM(require_picocolors());
+    init_ui();
+    HEADER_RX = /^([a-z]+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/;
+    MIN_BOX_WIDTH = 60;
+  }
+});
+
+// src/commit-helpers.ts
+function applyCliTypeScopeToRules(rules, type, scope) {
+  let next = { ...rules };
+  if (type) {
+    next = { ...next, types: [type] };
+  }
+  if (scope) {
+    next = { ...next, scopes: [scope] };
+  }
+  return next;
+}
+function generationHintsFromArgs(split, forceBody) {
+  const h = {};
+  if (split) h.split = true;
+  if (forceBody) h.force_body = true;
+  return Object.keys(h).length > 0 ? h : void 0;
+}
+function splitCommitMessageForDisplay(message) {
+  const t = message.replace(/\r\n/g, "\n").trimEnd();
+  const doubleNl = t.indexOf("\n\n");
+  if (doubleNl !== -1) {
+    const head = t.slice(0, doubleNl);
+    const subject = head.split("\n")[0]?.trim() ?? "";
+    return { subject, body: t.slice(doubleNl + 2).trimEnd() };
+  }
+  const firstNl = t.indexOf("\n");
+  if (firstNl === -1) {
+    return { subject: t.trim(), body: "" };
+  }
+  return {
+    subject: t.slice(0, firstNl).trim(),
+    body: t.slice(firstNl + 1).trimEnd()
+  };
+}
+function formatVerboseCommitDiagnostics(diagnostics, roundTripMs) {
+  const lines = [`api_round_trip_ms: ${roundTripMs}`];
+  if (diagnostics !== void 0) {
+    lines.push(JSON.stringify(diagnostics, null, 2));
+  }
+  return lines.join("\n");
+}
+async function interactiveRefineMessage(initial, opts) {
+  if (opts.skip) return { action: "accept", message: initial };
+  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    process.stderr.write(`
+${initial}
+
+`);
+    const choice = (await rl.question("Keep? [Y/n/e]: ")).trim().toLowerCase();
+    if (choice === "n") {
+      return { action: "abort" };
+    }
+    if (choice === "e") {
+      process.stderr.write("Enter new message (end with a line containing only .):\n");
+      const lines = [];
+      while (true) {
+        const line = await rl.question("");
+        if (line === ".") break;
+        lines.push(line);
+      }
+      const edited = lines.join("\n").trim();
+      return { action: "edit", message: edited.length > 0 ? edited : initial };
+    }
+    return { action: "accept", message: initial };
+  } finally {
+    rl.close();
+  }
+}
+async function promptYesNo(question, defaultYes = true) {
+  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  try {
+    const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+    if (answer === "n" || answer === "no") return false;
+    if (answer === "y" || answer === "yes") return true;
+    return defaultYes;
+  } finally {
+    rl.close();
+  }
+}
+async function confirmCommit(prompt2, opts) {
+  if (opts.skip) return { action: "commit" };
+  const rl = import_promises.default.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const ans = (await rl.question(prompt2)).trim().toLowerCase();
+    if (ans !== "y" && ans !== "yes") {
+      return { action: "abort" };
+    }
+    return { action: "commit" };
+  } finally {
+    rl.close();
+  }
+}
+function shouldSkipTTYInteraction(hookMode) {
+  return hookMode === true || process.stdin.isTTY !== true;
+}
+function logVerboseDiagnostics(dim, verbose, quiet, diagnostics, roundTripMs) {
+  if (!verbose || quiet) return;
+  process.stderr.write(
+    `
+${formatVerboseCommitDiagnostics(diagnostics, roundTripMs)}
+`
+  );
+  dim("(verbose diagnostics on stderr)");
+}
+function isDisplayOpts(opts) {
+  return typeof opts === "object" && opts !== null && "log" in opts;
+}
+function createSilentLog() {
+  return {
+    step: () => {
+    },
+    success: () => {
+    },
+    error: (msg) => console.error(msg),
+    dim: () => {
+    }
+  };
+}
+function displayCommitMessage(message, opts) {
+  const display = isDisplayOpts(opts) ? opts : { log: opts };
+  const log = display.log;
+  const { subject, body } = splitCommitMessageForDisplay(message);
+  const tw = getTerminalWidth();
+  const useRich = shouldUseRichOutput({
+    isTTY: display.isTTY ?? !!process.stderr.isTTY,
+    noColor: display.isColor === false,
+    width: tw,
+    style: display.style ?? "rich"
+  });
+  if (useRich) {
+    const tree = display.stagedFiles && display.stagedFiles.length > 0 ? renderFileTree(display.stagedFiles, 8) : "";
+    if (tree) {
+      process.stderr.write(tree + "\n");
+    }
+    const boxed = renderBoxedCommit(subject, body, {
+      width: Math.min(Math.max(tw - 4, 60), 80),
+      isColor: !!display.isColor
+    });
+    process.stderr.write(boxed + "\n");
+    if (display.stats) {
+      process.stderr.write(renderStatsLine(display.stats, !!display.isColor) + "\n");
+    }
+    return;
+  }
+  log.success(subject);
+  if (body) {
+    for (const line of body.split("\n")) {
+      log.dim(`  ${line}`);
+    }
+    process.stderr.write("\n");
+  }
+}
+var import_promises;
+var init_commit_helpers = __esm({
+  "src/commit-helpers.ts"() {
+    "use strict";
+    import_promises = __toESM(require("node:readline/promises"));
+    init_ui_rich();
+  }
+});
+
+// src/smart-diff.ts
+function sanitizeFilepath(path) {
+  return path.replace(/[\x00-\x1F\x7F[\]`]/g, "_").slice(0, 200);
+}
+function classifyFile(filepath) {
+  const basename = filepath.split("/").pop() ?? filepath;
+  if (LOCK_FILES.has(basename)) return "lock";
+  if (filepath.endsWith(".map")) return "sourcemap";
+  if (VENDORED_PREFIXES.some((p) => filepath.startsWith(p))) return "vendored";
+  if (GENERATED_PATTERNS.some((p) => p.test(filepath))) return "generated";
+  return "code";
+}
+function parseDiffIntoFiles(diff) {
+  const files = [];
+  const parts = diff.split(/^(diff --git .+)$/m);
+  for (let i = 1; i < parts.length; i += 2) {
+    const header = parts[i];
+    const content = parts[i + 1] ?? "";
+    const match = header.match(/diff --git a\/(.+?) b\/(.+)/);
+    const filepath = match?.[2] ?? "unknown";
+    const lines = content.split("\n");
+    let additions = 0;
+    let deletions = 0;
+    for (const line of lines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+      else if (line.startsWith("-") && !line.startsWith("---")) deletions++;
+    }
+    files.push({ filepath, content: header + content, additions, deletions });
+  }
+  return files;
+}
+function isMinified(content) {
+  const lines = content.split("\n").filter(
+    (l) => (l.startsWith("+") || l.startsWith("-")) && !l.startsWith("+++") && !l.startsWith("---")
+  );
+  if (lines.length === 0) return false;
+  return lines.some((l) => l.length > 500);
+}
+function buildFileSummary(file) {
+  const sizeKB = Math.round(file.content.length / 1024);
+  return `[modified: ${sanitizeFilepath(file.filepath)} \u2014 +${file.additions} \u2212${file.deletions} lines, ~${sizeKB}KB]
+`;
+}
+function preprocessDiffWithSizeBudget(diff, maxBytes = 5 * 1024 * 1024) {
+  const files = parseDiffIntoFiles(diff);
+  if (files.length === 0) {
+    return { processedDiff: diff, summarized: [], aggressivelySummarized: [], tokensSaved: 0 };
+  }
+  const entries = [];
+  const summarized = [];
+  let tokensSaved = 0;
+  for (const file of files) {
+    const classification = classifyFile(file.filepath);
+    switch (classification) {
+      case "sourcemap":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({ file, isNoise: true, summaryLine: null });
+        break;
+      case "lock":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({
+          file,
+          isNoise: true,
+          summaryLine: `[lock file updated: ${sanitizeFilepath(file.filepath)} (+${file.additions} \u2212${file.deletions} lines)]
+`
+        });
+        break;
+      case "generated":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({
+          file,
+          isNoise: true,
+          summaryLine: `[generated: ${sanitizeFilepath(file.filepath)} (+${file.additions} \u2212${file.deletions})]
+`
+        });
+        break;
+      case "vendored":
+        tokensSaved += estimateTokens(file.content);
+        summarized.push(file.filepath);
+        entries.push({
+          file,
+          isNoise: true,
+          summaryLine: `[vendored: ${sanitizeFilepath(file.filepath)} updated]
+`
+        });
+        break;
+      case "code":
+        if (isMinified(file.content)) {
+          tokensSaved += estimateTokens(file.content);
+          const sizeKB = Math.round(file.content.length / 1024);
+          summarized.push(file.filepath);
+          entries.push({
+            file,
+            isNoise: true,
+            summaryLine: `[minified asset: ${sanitizeFilepath(file.filepath)} (${sizeKB} KB)]
+`
+          });
+        } else {
+          entries.push({ file, isNoise: false, summaryLine: null });
+        }
+        break;
+    }
+  }
+  const aggressiveMap = /* @__PURE__ */ new Map();
+  function buildOutput() {
+    const parts = [];
+    for (const entry of entries) {
+      if (entry.isNoise) {
+        if (entry.summaryLine !== null) parts.push(entry.summaryLine);
+      } else if (aggressiveMap.has(entry.file.filepath)) {
+        parts.push(aggressiveMap.get(entry.file.filepath));
+      } else {
+        parts.push(entry.file.content);
+      }
+    }
+    return parts.join("");
+  }
+  const codeEntries = entries.filter((e) => !e.isNoise);
+  let output = buildOutput();
+  if (output.length <= maxBytes) {
+    return {
+      processedDiff: output,
+      summarized,
+      aggressivelySummarized: [],
+      tokensSaved
+    };
+  }
+  const TIER1_THRESHOLD = 5 * 1024;
+  for (const entry of codeEntries) {
+    if (entry.file.content.length > TIER1_THRESHOLD && !aggressiveMap.has(entry.file.filepath)) {
+      tokensSaved += estimateTokens(entry.file.content);
+      aggressiveMap.set(entry.file.filepath, buildFileSummary(entry.file));
+    }
+  }
+  output = buildOutput();
+  if (output.length <= maxBytes) {
+    return {
+      processedDiff: output,
+      summarized,
+      aggressivelySummarized: [...aggressiveMap.keys()],
+      tokensSaved
+    };
+  }
+  const TIER2_THRESHOLD = 2 * 1024;
+  for (const entry of codeEntries) {
+    if (entry.file.content.length > TIER2_THRESHOLD && !aggressiveMap.has(entry.file.filepath)) {
+      tokensSaved += estimateTokens(entry.file.content);
+      aggressiveMap.set(entry.file.filepath, buildFileSummary(entry.file));
+    }
+  }
+  output = buildOutput();
+  if (output.length <= maxBytes) {
+    return {
+      processedDiff: output,
+      summarized,
+      aggressivelySummarized: [...aggressiveMap.keys()],
+      tokensSaved
+    };
+  }
+  for (const entry of codeEntries) {
+    if (!aggressiveMap.has(entry.file.filepath)) {
+      tokensSaved += estimateTokens(entry.file.content);
+      aggressiveMap.set(entry.file.filepath, buildFileSummary(entry.file));
+    }
+  }
+  return {
+    processedDiff: buildOutput(),
+    summarized,
+    aggressivelySummarized: [...aggressiveMap.keys()],
+    tokensSaved
+  };
+}
+var LOCK_FILES, GENERATED_PATTERNS, VENDORED_PREFIXES;
+var init_smart_diff = __esm({
+  "src/smart-diff.ts"() {
+    "use strict";
+    init_dist();
+    LOCK_FILES = /* @__PURE__ */ new Set([
+      "pnpm-lock.yaml",
+      "package-lock.json",
+      "yarn.lock",
+      "Cargo.lock",
+      "Gemfile.lock",
+      "poetry.lock",
+      "composer.lock",
+      "bun.lockb",
+      "shrinkwrap.json"
+    ]);
+    GENERATED_PATTERNS = [
+      /\.generated\.\w+$/,
+      /\.g\.dart$/,
+      /\.pb\.go$/,
+      /\.pb\.ts$/,
+      /(^|\/)\.prisma\/client\//,
+      /\/generated\//
+    ];
+    VENDORED_PREFIXES = ["vendor/", "third_party/", "node_modules/"];
+  }
+});
+
+// src/local.ts
+var local_exports = {};
+__export(local_exports, {
+  generateLocalBranchName: () => generateLocalBranchName,
+  getLocalProviderConfig: () => getLocalProviderConfig,
+  runLocalBranch: () => runLocalBranch,
+  runLocalCommit: () => runLocalCommit
+});
+function getLegacyProvider() {
+  try {
+    const p = (0, import_path8.join)(CONFIG_PATH2, "provider");
+    if ((0, import_fs8.existsSync)(p)) {
+      const v = (0, import_fs8.readFileSync)(p, "utf-8").trim().toLowerCase();
+      if (["ollama", "lmstudio", "openrouter", "custom", "cloudflare"].includes(v)) {
+        return v;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function getLegacyBaseUrl(provider) {
+  try {
+    const p = (0, import_path8.join)(CONFIG_PATH2, "base_url");
+    if ((0, import_fs8.existsSync)(p)) {
+      return (0, import_fs8.readFileSync)(p, "utf-8").trim();
+    }
+  } catch {
+  }
+  return PROVIDER_URLS[provider] ?? "";
+}
+function getLegacyModel(provider) {
+  try {
+    const p = (0, import_path8.join)(CONFIG_PATH2, "model");
+    if ((0, import_fs8.existsSync)(p)) {
+      const v = (0, import_fs8.readFileSync)(p, "utf-8").trim();
+      if (v) return v;
+    }
+  } catch {
+  }
+  return DEFAULT_MODELS[provider] ?? "";
+}
+function getLocalProviderConfig() {
+  const config2 = getConfig();
+  const provider = config2.provider ?? getLegacyProvider();
+  if (!provider) return null;
+  const baseUrl = config2.apiUrl ?? getLegacyBaseUrl(provider) ?? PROVIDER_URLS[provider] ?? "";
+  if (!baseUrl) return null;
+  const model = config2.model ?? getLegacyModel(provider) ?? DEFAULT_MODELS[provider];
+  const apiKey = provider === "openrouter" || provider === "custom" ? getApiKey() : null;
+  if (provider === "openrouter" && !apiKey) return null;
+  return { provider, baseUrl, model, apiKey };
+}
+function buildUserPrompt(changes, diff, rules, recentCommits, hints) {
+  let prompt2 = `Generate a commit message for these changes:
+
+## File changes:
+<file_changes>
+${changes}
+</file_changes>
+
+## Diff:
+<diff>
+${diff}
+</diff>
+
+`;
+  if (recentCommits && recentCommits.length > 0) {
+    const history = recentCommits.slice(0, 10).join("\n");
+    prompt2 += `Recent commits on this branch (match style when appropriate):
+${history}
+
+`;
+  }
+  if (hints?.split) {
+    prompt2 += `MULTI-COMMIT MODE: If changes span multiple logical commits, focus the message on the primary change and mention other slices in the body.
+
+`;
+  }
+  if (hints?.force_body) {
+    prompt2 += `The user requires a BODY section after the subject line, even for small changes.
+
+`;
+  }
+  if (rules && Object.keys(rules).length > 0) {
+    prompt2 += `Rules: ${JSON.stringify(rules)}
+
+`;
+  }
+  prompt2 += `Important:
+- Follow conventional commit format: <type>(<scope>): <subject>
+- Response should be the commit message only, no explanations`;
+  return prompt2;
+}
+function buildRequest(provider, baseUrl, userContent, diff, changes, model, apiKey, rules, recentCommits, hints) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  if (provider === "openrouter") {
+    headers["HTTP-Referer"] = "https://github.com/Quikcommit-Internal/public";
+    headers["X-Title"] = "qc - AI Commit Message Generator";
+  }
+  let url;
+  let body;
+  switch (provider) {
+    case "ollama":
+      url = `${baseUrl}/api/generate`;
+      body = {
+        model,
+        prompt: userContent,
+        stream: false,
+        options: {}
+      };
+      return { url, body, headers: { "Content-Type": "application/json" } };
+    case "lmstudio":
+      url = `${baseUrl}/chat/completions`;
+      body = {
+        model,
+        stream: false,
+        messages: [
+          {
+            role: "system",
+            content: "You are a git commit message generator. Create conventional commit messages."
+          },
+          { role: "user", content: userContent }
+        ]
+      };
+      return { url, body, headers: { "Content-Type": "application/json" } };
+    case "openrouter":
+    case "custom":
+      url = `${baseUrl}/chat/completions`;
+      body = {
+        model,
+        stream: false,
+        messages: [
+          {
+            role: "system",
+            content: "You are a git commit message generator. Create conventional commit messages."
+          },
+          { role: "user", content: userContent }
+        ]
+      };
+      return { url, body, headers };
+    case "cloudflare": {
+      url = `${baseUrl.replace(/\/$/, "")}/commit`;
+      const payload = { diff, changes, rules };
+      if (recentCommits && recentCommits.length > 0) {
+        payload.recent_commits = recentCommits.slice(0, 10);
+      }
+      if (hints && Object.keys(hints).length > 0) {
+        payload.generation_hints = hints;
+      }
+      body = payload;
+      return { url, body, headers: { "Content-Type": "application/json" } };
+    }
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+function parseResponse(provider, data) {
+  const r = data;
+  switch (provider) {
+    case "ollama":
+      return r.response ?? "";
+    case "lmstudio":
+    case "openrouter":
+    case "custom": {
+      const choices = r.choices;
+      return choices?.[0]?.message?.content ?? "";
+    }
+    case "cloudflare":
+      return r.commit?.response ?? "";
+    default:
+      return "";
+  }
+}
+async function runLocalCommit(args) {
+  const silent = !!(args.hookMode || args.quiet);
+  const ui2 = getUI();
+  const log = silent ? createSilentLog() : ui2.log;
+  if (!isGitRepo()) {
+    throw new Error("Not a git repository.");
+  }
+  if (!hasStagedChanges()) {
+    throw new Error("No staged changes. Stage files with `git add` first.");
+  }
+  const local = getLocalProviderConfig();
+  if (!local) {
+    throw new Error(
+      "No local provider configured. Set provider in ~/.config/qc/config.json or run with SaaS (qc login)."
+    );
+  }
+  const config2 = getConfig();
+  const excludes = [...config2.excludes ?? [], ...args.exclude];
+  let diff = getStagedDiff(excludes);
+  const changes = getStagedFiles();
+  if (!args.noSmartDiff) {
+    const smartResult = preprocessDiffWithSizeBudget(diff, 5 * 1024 * 1024);
+    diff = smartResult.processedDiff;
+    if (smartResult.summarized.length > 0 && !silent) {
+      log.step(
+        `smart-diff: ${smartResult.summarized.length} file(s) summarized (saved ~${Math.round(smartResult.tokensSaved / 1e3)}K tokens)`
+      );
+    }
+    if (smartResult.aggressivelySummarized.length > 0 && !silent) {
+      log.step(
+        `large-diff: ${smartResult.aggressivelySummarized.length} additional file(s) summarized to fit (commit message may be less specific)`
+      );
+    }
+  }
+  let rules = { ...await detectCommitlintRules(), ...config2.rules ?? {} };
+  const workspace = detectWorkspace();
+  if (workspace) {
+    const stagedFiles = changes.trim().split("\n").filter(Boolean);
+    const scope = autoDetectScope(stagedFiles, workspace);
+    if (scope) {
+      const scopes = scope.split(",").map((s) => s.trim());
+      rules = { ...rules, scopes };
+    }
+  }
+  rules = applyCliTypeScopeToRules(rules, args.type, args.scope);
+  const recentCommits = args.noContext ? void 0 : getRecentBranchCommits(5);
+  const generationHints = generationHintsFromArgs(args.split, args.forceBody);
+  const skipInteractive = silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
+  const skipConfirm = args.dryRun || args.messageOnly || silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
+  const model = args.model ?? local.model;
+  const modelDisplay = model ?? local.model ?? "default";
+  const userContent = buildUserPrompt(
+    changes,
+    diff,
+    Object.keys(rules).length > 0 ? rules : void 0,
+    recentCommits,
+    generationHints
+  );
+  const { url, body, headers } = buildRequest(
+    local.provider,
+    local.baseUrl,
+    userContent,
+    diff,
+    changes,
+    model,
+    local.apiKey,
+    rules,
+    recentCommits,
+    generationHints
+  );
+  if (!url || url.includes("YOUR-WORKER")) {
+    throw new Error(
+      "Cloudflare provider requires api_url. Run: qc config set api_url https://your-worker.workers.dev"
+    );
+  }
+  const spinner = ui2.spinner(`generating commit (${modelDisplay} via ${local.provider})...`);
+  if (!silent) spinner.start();
+  const t0 = Date.now();
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+  } finally {
+    spinner.stop();
+  }
+  const roundTripMs = Date.now() - t0;
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Provider error (${res.status}): ${text}`);
+  }
+  const data = await res.json();
+  let message = parseResponse(local.provider, data);
+  message = message.replace(/\\n/g, "\n").replace(/\\r/g, "").trim();
+  if (!message) {
+    throw new Error("Failed to generate commit message.");
+  }
+  const diagnostics = local.provider === "cloudflare" && typeof data === "object" && data !== null ? data.diagnostics : void 0;
+  logVerboseDiagnostics((msg) => log.dim(msg), args.verbose, args.quiet, diagnostics, roundTripMs);
+  if (args.interactive) {
+    if (shouldSkipTTYInteraction(args.hookMode)) {
+      if (!silent) log.dim("(--interactive ignored: not running in a TTY)");
+    } else {
+      const refineResult = await interactiveRefineMessage(message, { skip: skipInteractive });
+      if (refineResult.action === "abort") {
+        return;
+      }
+      message = refineResult.message;
+    }
+  }
+  if (args.messageOnly) {
+    console.log(message);
+    return;
+  }
+  if (!silent) {
+    const stagedPaths = changes.trim().split("\n").filter(Boolean);
+    const short = getStagedDiffShortstat();
+    const tokenEst = diagnostics && typeof diagnostics === "object" && diagnostics !== null && "tokenUsage" in diagnostics ? diagnostics.tokenUsage?.totalEstimated : void 0;
+    displayCommitMessage(message, {
+      log,
+      isColor: ui2.isColor,
+      isTTY: !!process.stderr.isTTY,
+      style: "rich",
+      stagedFiles: stagedPaths,
+      stats: {
+        files: stagedPaths.length,
+        additions: short.additions,
+        deletions: short.deletions,
+        ...tokenEst !== void 0 ? { tokens: tokenEst } : {}
+      }
+    });
+  }
+  if (args.dryRun) {
+    return;
+  }
+  if (args.confirm) {
+    const confirmResult = await confirmCommit("Proceed with commit? [y/N]: ", { skip: skipConfirm });
+    if (confirmResult.action === "abort") {
+      return;
+    }
+  }
+  gitCommit(message);
+  if (args.push) {
+    gitPush();
+  }
+}
+async function generateLocalBranchName(opts) {
+  const local = getLocalProviderConfig();
+  if (!local) {
+    throw new Error("No local provider configured. Set provider with `qc --use-ollama` etc.");
+  }
+  const sections = [];
+  sections.push("Generate a git branch name in the format <type>/<kebab-case-slug>.");
+  sections.push("Type must be one of: feat, fix, refactor, perf, docs, test, chore, ci.");
+  sections.push("Slug: 2-5 words, lowercase, hyphen-separated, max 55 chars.");
+  sections.push("Output ONLY the branch name on a single line. No explanation.");
+  sections.push("");
+  if (opts.description) {
+    sections.push("DESCRIPTION:");
+    sections.push(opts.description);
+  } else if (opts.recentCommits && opts.recentCommits.length > 0) {
+    sections.push("RECENT COMMITS:");
+    for (const c of opts.recentCommits) sections.push(`- ${c}`);
+  } else if (opts.diff) {
+    sections.push("DIFF:");
+    sections.push(opts.diff.slice(0, 3e4));
+  }
+  const userContent = sections.join("\n");
+  const model = opts.model ?? local.model;
+  const headers = { "Content-Type": "application/json" };
+  if (local.apiKey) headers.Authorization = `Bearer ${local.apiKey}`;
+  if (local.provider === "openrouter") {
+    headers["HTTP-Referer"] = "https://github.com/Quikcommit-Internal/public";
+    headers["X-Title"] = "qc - AI Commit Message Generator";
+  }
+  let url;
+  let body;
+  switch (local.provider) {
+    case "ollama":
+      url = `${local.baseUrl}/api/generate`;
+      body = { model, prompt: userContent, stream: false, options: {} };
+      break;
+    case "lmstudio":
+    case "openrouter":
+    case "custom":
+      url = `${local.baseUrl}/chat/completions`;
+      body = {
+        model,
+        stream: false,
+        messages: [
+          {
+            role: "system",
+            content: "You suggest concise git branch names. Reply with the branch name only."
+          },
+          { role: "user", content: userContent }
+        ]
+      };
+      break;
+    case "cloudflare":
+      url = `${local.baseUrl.replace(/\/$/, "")}/branch`;
+      body = {
+        diff: opts.diff,
+        changes: opts.changes,
+        recent_commits: opts.recentCommits,
+        description: opts.description,
+        model,
+        cf_model: model,
+        ...opts.rules ? { rules: opts.rules } : {}
+      };
+      break;
+  }
+  if (!url || url.includes("YOUR-WORKER")) {
+    throw new Error(
+      "Cloudflare provider requires api_url. Run: qc config set api_url https://your-worker.workers.dev"
+    );
+  }
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+  } catch {
+    const fallback = deterministicBranchName({ files: opts.changes?.split("\n").filter(Boolean), description: opts.description });
+    return ensureUniqueName(fallback.name, branchExists);
+  }
+  if (!res.ok) {
+    const fallback = deterministicBranchName({ files: opts.changes?.split("\n").filter(Boolean), description: opts.description });
+    return ensureUniqueName(fallback.name, branchExists);
+  }
+  const data = await res.json();
+  let raw;
+  if (local.provider === "cloudflare") {
+    const r = data;
+    const br = r.branch;
+    raw = typeof br?.name === "string" ? br.name : "";
+  } else if (local.provider === "ollama") {
+    raw = data.response ?? "";
+  } else {
+    const choices = data.choices;
+    raw = choices?.[0]?.message?.content ?? "";
+  }
+  raw = raw.replace(/[\r\n].*$/s, "").trim();
+  const sanitized = sanitizeBranchName(raw);
+  if (!sanitized) {
+    const fallback = deterministicBranchName({ files: opts.changes?.split("\n").filter(Boolean), description: opts.description });
+    return ensureUniqueName(fallback.name, branchExists);
+  }
+  return ensureUniqueName(sanitized, branchExists);
+}
+async function runLocalBranch(opts) {
+  const local = getLocalProviderConfig();
+  if (!local) {
+    throw new Error("No local provider configured. Set provider with `qc --use-ollama` etc.");
+  }
+  const ui2 = getUI();
+  const log = ui2.log;
+  const spinner = ui2.spinner(`generating branch name (${opts.model ?? local.model} via ${local.provider})...`);
+  if (process.stderr.isTTY) spinner.start();
+  let final;
+  try {
+    final = await generateLocalBranchName({
+      description: opts.description,
+      diff: opts.diff,
+      changes: opts.changes,
+      recentCommits: opts.recentCommits,
+      model: opts.model,
+      rules: opts.rules
+    });
+  } catch {
+    const filesArr = opts.changes?.split("\n").filter(Boolean) ?? [];
+    const fallback = deterministicBranchName({ files: filesArr, description: opts.description });
+    final = ensureUniqueName(fallback.name, branchExists);
+    log.dim("(used local fallback name; AI generation failed)");
+  } finally {
+    spinner.stop();
+  }
+  log.success(`branch name: ${final}`);
+  const baseRef = opts.baseRef ?? "HEAD";
+  if (opts.noSwitch) {
+    createBranch(final, baseRef);
+    log.success(`created ${final} (not switched)`);
+  } else {
+    createAndCheckoutBranch(final, baseRef);
+    log.success(`switched to ${final}`);
+  }
+  if (opts.push) {
+    gitPushSetUpstream(final);
+    log.success(`pushed origin/${final}`);
+  }
+}
+var import_fs8, import_path8, import_os4, CONFIG_PATH2, PROVIDER_URLS, DEFAULT_MODELS;
+var init_local = __esm({
+  "src/local.ts"() {
+    "use strict";
+    import_fs8 = require("fs");
+    import_path8 = require("path");
+    import_os4 = require("os");
+    init_config();
+    init_dist();
+    init_git();
+    init_monorepo();
+    init_commitlint();
+    init_smart_diff();
+    init_ui();
+    init_commit_helpers();
+    init_branch_name();
+    CONFIG_PATH2 = (0, import_path8.join)((0, import_os4.homedir)(), CONFIG_DIR);
+    PROVIDER_URLS = {
+      ollama: "http://localhost:11434",
+      lmstudio: "http://localhost:1234/v1",
+      openrouter: "https://openrouter.ai/api/v1",
+      custom: "",
+      cloudflare: ""
+    };
+    DEFAULT_MODELS = {
+      ollama: "codellama",
+      lmstudio: "default",
+      openrouter: "google/gemini-flash-1.5-8b",
+      custom: "",
+      cloudflare: "@cf/qwen/qwen2.5-coder-32b-instruct"
+    };
+  }
+});
+
+// src/commands/branch.ts
+var branch_exports = {};
+__export(branch_exports, {
+  runBranch: () => runBranch
+});
+function branchGenerationRules(cfg) {
+  const types = cfg.branch?.generation?.types;
+  if (types && types.length > 0) return { types: [...types] };
+  return void 0;
+}
+function finalizeGeneratedBranchName(raw) {
+  return finalizeBranchName(raw, branchExists);
+}
+async function runBranch(opts) {
+  const ui2 = getUI();
+  const log = ui2.log;
+  if (!isGitRepo()) {
+    log.error("Not a git repository.");
+    process.exit(1);
+  }
+  const baseRef = opts.from ?? "HEAD";
+  const config2 = getConfig();
+  const model = opts.model ?? config2.model;
+  const genRules = branchGenerationRules(config2);
+  if (opts.rescue) {
+    const state = detectProtectedBranchState({
+      protectedBranches: config2.branch?.protectedBranches,
+      detectDefault: config2.branch?.detectDefault
+    });
+    if (!state.isProtected) {
+      throw new Error(
+        "`--rescue` only applies on a protected branch (e.g. main). The current branch is not protected."
+      );
+    }
+    if (state.commitsAhead === 0) {
+      throw new Error(
+        "No commits ahead of upstream to rescue. Push your branch or use `qc branch` without `--rescue`."
+      );
+    }
+    let final2;
+    if (opts.explicitName) {
+      const sanitized = sanitizeBranchName(opts.explicitName);
+      if (!sanitized) {
+        throw new Error(`invalid branch name: ${opts.explicitName}`);
+      }
+      final2 = finalizeBranchName(sanitized, branchExists);
+    } else {
+      const recent = getRecentBranchCommits(state.commitsAhead);
+      const apiKey2 = opts.apiKey ?? getApiKey();
+      if (apiKey2) {
+        const spinner2 = ui2.spinner(`generating branch name (${model ?? "default"})...`);
+        if (process.stderr.isTTY) spinner2.start();
+        try {
+          const client = new ApiClient({ apiKey: apiKey2 });
+          try {
+            const result2 = await client.generateBranchName({
+              recent_commits: recent,
+              model: opts.model,
+              description: opts.message,
+              rules: genRules
+            });
+            final2 = finalizeGeneratedBranchName(result2.name);
+          } catch {
+            const fallback = deterministicBranchName({
+              description: recent.join(" ") || opts.message
+            });
+            final2 = finalizeBranchName(fallback.name, branchExists);
+            log.dim("(used deterministic fallback name; API generation failed)");
+          }
+        } finally {
+          spinner2.stop();
+        }
+      } else {
+        const { getLocalProviderConfig: getLocalProviderConfig2, generateLocalBranchName: generateLocalBranchName2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+        if (!getLocalProviderConfig2()) {
+          throw new Error(
+            "Not authenticated. Run `qc login` first, or configure a local provider for `--rescue`."
+          );
+        }
+        const spinner2 = ui2.spinner(`generating branch name (${model ?? "default"} via local)...`);
+        if (process.stderr.isTTY) spinner2.start();
+        try {
+          try {
+            const name = await generateLocalBranchName2({
+              recentCommits: recent,
+              model: opts.model,
+              description: opts.message,
+              rules: genRules
+            });
+            final2 = finalizeBranchName(name, branchExists, { skipUniqueness: true });
+          } catch {
+            const fallback = deterministicBranchName({
+              description: recent.join(" ") || opts.message
+            });
+            final2 = finalizeBranchName(fallback.name, branchExists);
+            log.dim("(used deterministic fallback name; local provider failed)");
+          }
+        } finally {
+          spinner2.stop();
+        }
+      }
+    }
+    log.success(`branch name: ${final2}`);
+    if (opts.dryRun) {
+      log.dim("(dry-run; not running rescue)");
+      return;
+    }
+    if (!process.stdin.isTTY) {
+      throw new Error("`--rescue` requires an interactive terminal to confirm (or use `qc branch <name>` after arranging commits manually).");
+    }
+    log.dim(
+      `About to: 1) create ${final2} at HEAD, 2) reset ${state.branch} to upstream, 3) switch to ${final2}`
+    );
+    if (!await promptYesNo("Continue with rescue?")) {
+      log.dim("aborted.");
+      return;
+    }
+    rescueCommits({ currentBranch: state.branch, newBranch: final2 });
+    log.success(`moved ${state.commitsAhead} commit(s) to ${final2}`);
+    log.success(`${state.branch} reset to upstream`);
+    if (opts.push) {
+      gitPushSetUpstream(final2);
+      log.success(`pushed origin/${final2}`);
+    }
+    return;
+  }
+  if (opts.explicitName) {
+    const sanitized = sanitizeBranchName(opts.explicitName);
+    if (!sanitized) {
+      throw new Error(`invalid branch name: ${opts.explicitName}`);
+    }
+    const final2 = finalizeBranchName(sanitized, branchExists);
+    if (opts.dryRun) {
+      log.success(`would create branch: ${final2}`);
+      return;
+    }
+    if (opts.noSwitch) {
+      createBranch(final2, baseRef);
+      log.success(`created branch ${final2} (not switched)`);
+    } else {
+      createAndCheckoutBranch(final2, baseRef);
+      log.success(`switched to ${final2}`);
+    }
+    if (opts.push) {
+      gitPushSetUpstream(final2);
+      log.success(`pushed origin/${final2}`);
+    }
+    return;
+  }
+  const payload = { model, rules: genRules };
+  if (opts.message) {
+    payload.description = opts.message;
+  } else if (opts.fromCommits) {
+    payload.recent_commits = getRecentBranchCommits(10);
+  } else {
+    if (!hasStagedChanges()) {
+      throw new Error(
+        "No staged changes detected. Stage with `git add`, or provide -m '<description>'."
+      );
+    }
+    payload.diff = getStagedDiff(config2.excludes ?? []);
+    payload.changes = getStagedFiles();
+  }
+  const apiKey = opts.apiKey ?? getApiKey();
+  if (!apiKey) {
+    const { getLocalProviderConfig: getLocalProviderConfig2, runLocalBranch: runLocalBranch2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+    if (getLocalProviderConfig2()) {
+      await runLocalBranch2({
+        description: opts.message,
+        diff: opts.message ? void 0 : payload.diff,
+        changes: opts.message ? void 0 : payload.changes,
+        recentCommits: payload.recent_commits,
+        model: opts.model,
+        noSwitch: opts.noSwitch,
+        push: opts.push,
+        baseRef,
+        rules: genRules
+      });
+      return;
+    }
+    throw new Error("Not authenticated. Run `qc login` first, or provide --message.");
+  }
+  const spinner = ui2.spinner(`generating branch name (${model ?? "default"})...`);
+  if (process.stderr.isTTY) spinner.start();
+  let result;
+  try {
+    const client = new ApiClient({ apiKey });
+    result = await client.generateBranchName(payload);
+  } finally {
+    spinner.stop();
+  }
+  const final = finalizeGeneratedBranchName(result.name);
+  log.success(`branch name: ${final}`);
+  if (opts.dryRun) {
+    log.dim(`(dry-run; not creating)`);
+    return;
+  }
+  if (opts.noSwitch) {
+    createBranch(final, baseRef);
+    log.success(`created ${final} (not switched)`);
+  } else {
+    createAndCheckoutBranch(final, baseRef);
+    log.success(`switched to ${final}`);
+  }
+  if (opts.push) {
+    gitPushSetUpstream(final);
+    log.success(`pushed origin/${final}`);
+  }
+}
+var init_branch2 = __esm({
+  "src/commands/branch.ts"() {
+    "use strict";
+    init_api();
+    init_config();
+    init_branch_rescue();
+    init_protected_branch_guard();
+    init_git();
+    init_branch_name();
+    init_commit_helpers();
+    init_ui();
+  }
+});
+
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -8712,12 +10534,12 @@ function init(options) {
     console.error("Error: Not a git repository");
     process.exit(1);
   }
-  const hookPath = (0, import_path8.join)(hooksDir, "prepare-commit-msg");
+  const hookPath = (0, import_path9.join)(hooksDir, "prepare-commit-msg");
   if (options.uninstall) {
-    if ((0, import_fs8.existsSync)(hookPath)) {
-      const content = (0, import_fs8.readFileSync)(hookPath, "utf-8");
+    if ((0, import_fs9.existsSync)(hookPath)) {
+      const content = (0, import_fs9.readFileSync)(hookPath, "utf-8");
       if (content.includes("Quikcommit")) {
-        (0, import_fs8.unlinkSync)(hookPath);
+        (0, import_fs9.unlinkSync)(hookPath);
         console.log("Quikcommit hook removed.");
       } else {
         console.log("Hook exists but was not installed by Quikcommit. Skipping.");
@@ -8727,8 +10549,8 @@ function init(options) {
     }
     return;
   }
-  if ((0, import_fs8.existsSync)(hookPath)) {
-    const content = (0, import_fs8.readFileSync)(hookPath, "utf-8");
+  if ((0, import_fs9.existsSync)(hookPath)) {
+    const content = (0, import_fs9.readFileSync)(hookPath, "utf-8");
     if (content.includes("Quikcommit")) {
       console.log("Quikcommit hook is already installed.");
       return;
@@ -8738,17 +10560,17 @@ function init(options) {
     );
     process.exit(1);
   }
-  (0, import_fs8.writeFileSync)(hookPath, HOOK_CONTENT);
-  (0, import_fs8.chmodSync)(hookPath, 493);
+  (0, import_fs9.writeFileSync)(hookPath, HOOK_CONTENT);
+  (0, import_fs9.chmodSync)(hookPath, 493);
   console.log("Quikcommit hook installed.");
   console.log("Now just run `git commit` and a message will be generated automatically.");
 }
-var import_fs8, import_path8, import_child_process6, HOOK_CONTENT;
+var import_fs9, import_path9, import_child_process6, HOOK_CONTENT;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
-    import_fs8 = require("fs");
-    import_path8 = require("path");
+    import_fs9 = require("fs");
+    import_path9 = require("path");
     import_child_process6 = require("child_process");
     HOOK_CONTENT = `#!/bin/sh
 # Quikcommit - auto-generate commit messages
@@ -8823,10 +10645,10 @@ function detectLocalCommitlintRules() {
     "commitlint.config.mjs"
   ];
   for (const file of files) {
-    const path = (0, import_path9.join)(cwd, file);
-    if (!(0, import_fs9.existsSync)(path)) continue;
+    const path = (0, import_path10.join)(cwd, file);
+    if (!(0, import_fs10.existsSync)(path)) continue;
     try {
-      const content = (0, import_fs9.readFileSync)(path, "utf-8");
+      const content = (0, import_fs10.readFileSync)(path, "utf-8");
       let parsed;
       if (file.endsWith(".json") || file === ".commitlintrc") {
         parsed = JSON.parse(content);
@@ -8838,10 +10660,10 @@ function detectLocalCommitlintRules() {
     } catch {
     }
   }
-  const pkgPath = (0, import_path9.join)(cwd, "package.json");
-  if ((0, import_fs9.existsSync)(pkgPath)) {
+  const pkgPath = (0, import_path10.join)(cwd, "package.json");
+  if ((0, import_fs10.existsSync)(pkgPath)) {
     try {
-      const content = (0, import_fs9.readFileSync)(pkgPath, "utf-8");
+      const content = (0, import_fs10.readFileSync)(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.commitlint) {
         const rules = mapCommitlintToRules(pkg.commitlint);
@@ -8904,20 +10726,20 @@ async function team(subcommand, args) {
       process.exit(1);
   }
 }
-var import_fs9, import_path9;
+var import_fs10, import_path10;
 var init_team = __esm({
   "src/commands/team.ts"() {
     "use strict";
-    import_fs9 = require("fs");
-    import_path9 = require("path");
+    import_fs10 = require("fs");
+    import_path10 = require("path");
     init_api();
     init_config();
   }
 });
 
 // src/commands/config.ts
-var config_exports = {};
-__export(config_exports, {
+var config_exports2 = {};
+__export(config_exports2, {
   config: () => config
 });
 function config(args) {
@@ -9030,459 +10852,698 @@ var init_upgrade = __esm({
   }
 });
 
-// src/local.ts
-var local_exports = {};
-__export(local_exports, {
-  getLocalProviderConfig: () => getLocalProviderConfig,
-  runLocalCommit: () => runLocalCommit
-});
-function getLegacyProvider() {
-  try {
-    const p = (0, import_path10.join)(CONFIG_PATH2, "provider");
-    if ((0, import_fs10.existsSync)(p)) {
-      const v = (0, import_fs10.readFileSync)(p, "utf-8").trim().toLowerCase();
-      if (["ollama", "lmstudio", "openrouter", "custom", "cloudflare"].includes(v)) {
-        return v;
-      }
-    }
-  } catch {
+// src/branch-guard.ts
+async function runBranchGuard(args, log) {
+  if (!shouldRunGuard({
+    allowProtected: !!args.allowProtected,
+    hookMode: !!args.hookMode,
+    isTTY: !!process.stdin.isTTY
+  })) {
+    return { action: "continue" };
+  }
+  const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const config2 = getConfig2();
+  const state = detectProtectedBranchState({
+    protectedBranches: config2.branch?.protectedBranches,
+    detectDefault: config2.branch?.detectDefault
+  });
+  if (!state.isProtected) {
+    return { action: "continue" };
   }
-  return null;
-}
-function getLegacyBaseUrl(provider) {
-  try {
-    const p = (0, import_path10.join)(CONFIG_PATH2, "base_url");
-    if ((0, import_fs10.existsSync)(p)) {
-      return (0, import_fs10.readFileSync)(p, "utf-8").trim();
-    }
-  } catch {
+  log.error(
+    `You're on ${state.branch} (a protected branch).` + (state.commitsAhead > 0 ? ` ${state.commitsAhead} commit(s) ahead of upstream.` : "")
+  );
+  let action;
+  let usedConfigDefault = false;
+  if (args.autoBranch) {
+    action = "branch";
+  } else if (config2.branch?.defaultAction === "branch") {
+    action = "branch";
+    usedConfigDefault = true;
+  } else if (config2.branch?.defaultAction === "continue") {
+    action = "continue";
+    usedConfigDefault = true;
+  } else {
+    action = await promptProtectedAction(state.mode);
   }
-  return PROVIDER_URLS[provider] ?? "";
-}
-function getLegacyModel(provider) {
-  try {
-    const p = (0, import_path10.join)(CONFIG_PATH2, "model");
-    if ((0, import_fs10.existsSync)(p)) {
-      const v = (0, import_fs10.readFileSync)(p, "utf-8").trim();
-      if (v) return v;
-    }
-  } catch {
+  if (action === "continue" && usedConfigDefault) {
+    log.dim("(continuing on protected branch per config `branch.defaultAction`)");
   }
-  return DEFAULT_MODELS[provider] ?? "";
-}
-function getLocalProviderConfig() {
-  const config2 = getConfig();
-  const provider = config2.provider ?? getLegacyProvider();
-  if (!provider) return null;
-  const baseUrl = config2.apiUrl ?? getLegacyBaseUrl(provider) ?? PROVIDER_URLS[provider] ?? "";
-  if (!baseUrl) return null;
-  const model = config2.model ?? getLegacyModel(provider) ?? DEFAULT_MODELS[provider];
-  const apiKey = provider === "openrouter" || provider === "custom" ? getApiKey() : null;
-  if (provider === "openrouter" && !apiKey) return null;
-  return { provider, baseUrl, model, apiKey };
-}
-function buildUserPrompt(changes, diff, rules) {
-  let prompt2 = `Generate a commit message for these changes:
-
-## File changes:
-<file_changes>
-${changes}
-</file_changes>
-
-## Diff:
-<diff>
-${diff}
-</diff>
-
-`;
-  if (rules && Object.keys(rules).length > 0) {
-    prompt2 += `Rules: ${JSON.stringify(rules)}
-
-`;
+  if (action === "abort") {
+    log.dim("aborted.");
+    return { action: "abort" };
   }
-  prompt2 += `Important:
-- Follow conventional commit format: <type>(<scope>): <subject>
-- Response should be the commit message only, no explanations`;
-  return prompt2;
-}
-function buildRequest(provider, baseUrl, userContent, diff, changes, model, apiKey, rules) {
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (apiKey) {
-    headers["Authorization"] = `Bearer ${apiKey}`;
+  if (action === "continue") {
+    return { action: "continue" };
   }
-  if (provider === "openrouter") {
-    headers["HTTP-Referer"] = "https://github.com/Quikcommit-Internal/public";
-    headers["X-Title"] = "qc - AI Commit Message Generator";
+  const stagedDiff = state.mode === "uncommitted" ? getStagedDiff(args.excludes ?? []) : "";
+  const stagedChanges = state.mode === "uncommitted" ? getStagedFiles() : "";
+  const recentCommits = state.mode === "rescue" ? getRecentBranchCommits(state.commitsAhead) : void 0;
+  const branchRules = args.branchRules ?? (config2.branch?.generation?.types && config2.branch.generation.types.length > 0 ? { types: [...config2.branch.generation.types] } : void 0);
+  const apiKey = args.apiKey;
+  const ui2 = getUI();
+  let generateLocalBranchNameFn;
+  if (!apiKey) {
+    const { getLocalProviderConfig: getLocalProviderConfig2, generateLocalBranchName: generateLocalBranchName2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+    if (!getLocalProviderConfig2()) {
+      log.error(
+        "Cannot generate branch name: not authenticated and no local provider configured. Run `qc login` or configure a local provider."
+      );
+      return { action: "abort" };
+    }
+    generateLocalBranchNameFn = generateLocalBranchName2;
+  }
+  const spinner = ui2.spinner(`generating branch name...`);
+  if (process.stderr.isTTY) spinner.start();
+  let rawName;
+  let usedFallback = false;
+  try {
+    if (apiKey) {
+      const client = new ApiClient({ apiKey });
+      try {
+        const branchResult = await client.generateBranchName({
+          diff: stagedDiff || void 0,
+          changes: stagedChanges || void 0,
+          recent_commits: recentCommits,
+          model: args.model,
+          rules: branchRules
+        });
+        rawName = branchResult.name;
+      } catch {
+        const fallbackInput = state.mode === "rescue" ? { files: [], description: recentCommits?.join(" ") ?? "" } : { files: stagedChanges ? stagedChanges.split("\n").filter(Boolean) : [] };
+        rawName = deterministicBranchName(fallbackInput).name;
+        usedFallback = true;
+      }
+    } else {
+      try {
+        rawName = await generateLocalBranchNameFn({
+          diff: stagedDiff || void 0,
+          changes: stagedChanges || void 0,
+          recentCommits,
+          model: args.model,
+          rules: branchRules
+        });
+      } catch {
+        const fallbackInput = state.mode === "rescue" ? { files: [], description: recentCommits?.join(" ") ?? "" } : { files: stagedChanges ? stagedChanges.split("\n").filter(Boolean) : [] };
+        rawName = deterministicBranchName(fallbackInput).name;
+        usedFallback = true;
+      }
+    }
+  } finally {
+    spinner.stop();
   }
-  let url;
-  let body;
-  switch (provider) {
-    case "ollama":
-      url = `${baseUrl}/api/generate`;
-      body = {
-        model,
-        prompt: userContent,
-        stream: false,
-        options: {}
-      };
-      return { url, body, headers: { "Content-Type": "application/json" } };
-    case "lmstudio":
-      url = `${baseUrl}/chat/completions`;
-      body = {
-        model,
-        stream: false,
-        messages: [
-          {
-            role: "system",
-            content: "You are a git commit message generator. Create conventional commit messages."
-          },
-          { role: "user", content: userContent }
-        ]
-      };
-      return { url, body, headers: { "Content-Type": "application/json" } };
-    case "openrouter":
-    case "custom":
-      url = `${baseUrl}/chat/completions`;
-      body = {
-        model,
-        stream: false,
-        messages: [
-          {
-            role: "system",
-            content: "You are a git commit message generator. Create conventional commit messages."
-          },
-          { role: "user", content: userContent }
-        ]
-      };
-      return { url, body, headers };
-    case "cloudflare":
-      url = `${baseUrl.replace(/\/$/, "")}/commit`;
-      body = { diff, changes, rules };
-      return { url, body, headers: { "Content-Type": "application/json" } };
-    default:
-      throw new Error(`Unknown provider: ${provider}`);
+  if (usedFallback) {
+    log.dim("(used local fallback name; AI generation failed)");
   }
-}
-function parseResponse(provider, data) {
-  const r = data;
-  switch (provider) {
-    case "ollama":
-      return r.response ?? "";
-    case "lmstudio":
-    case "openrouter":
-    case "custom": {
-      const choices = r.choices;
-      return choices?.[0]?.message?.content ?? "";
+  let final;
+  try {
+    final = finalizeBranchName(rawName, branchExists);
+  } catch {
+    const generatorName = usedFallback ? "deterministic fallback" : apiKey ? "API generator" : "local provider";
+    log.error(`Invalid branch name from ${generatorName}: ${rawName}`);
+    return { action: "abort" };
+  }
+  log.success(`branch name: ${final}`);
+  if (state.mode === "rescue") {
+    log.dim(
+      `About to: 1) create ${final} at HEAD, 2) reset ${state.branch} to upstream, 3) switch to ${final}`
+    );
+    const confirmed = await promptYesNo("Continue with rescue?");
+    if (!confirmed) {
+      log.dim("aborted.");
+      return { action: "abort" };
     }
-    case "cloudflare":
-      return r.commit?.response ?? "";
-    default:
-      return "";
+    try {
+      rescueCommits({ currentBranch: state.branch, newBranch: final });
+      log.success(`moved ${state.commitsAhead} commit(s) to ${final}`);
+      log.success(`${state.branch} reset to upstream`);
+    } catch (err) {
+      log.error(`Rescue failed: ${err instanceof Error ? err.message : String(err)}`);
+      return { action: "abort" };
+    }
+    return { action: "done" };
+  }
+  createAndCheckoutBranch(final);
+  log.success(`switched to ${final}`);
+  return { action: "continue" };
+}
+async function promptProtectedAction(mode) {
+  const rl = import_promises2.default.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const question = mode === "rescue" ? "Move commits to a new branch? [B/c/a] " : "Create a new branch first? [B/c/a] ";
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    if (answer === "" || answer === "b" || answer === "y") return "branch";
+    if (answer === "c") return "continue";
+    return "abort";
+  } finally {
+    rl.close();
   }
 }
-async function runLocalCommit(messageOnly, push, modelFlag) {
+var import_promises2;
+var init_branch_guard = __esm({
+  "src/branch-guard.ts"() {
+    "use strict";
+    import_promises2 = __toESM(require("node:readline/promises"));
+    init_api();
+    init_git();
+    init_protected_branch_guard();
+    init_branch_rescue();
+    init_branch_name();
+    init_ui();
+    init_commit_helpers();
+  }
+});
+
+// src/commands/commit.ts
+var commit_exports = {};
+__export(commit_exports, {
+  runCommit: () => runCommit
+});
+async function runCommit(args) {
+  const { messageOnly, push, apiKey: apiKeyFlag, hookMode, model: modelFlag, all } = args;
+  const silent = !!(hookMode || args.quiet);
+  const ui2 = getUI();
+  const log = silent ? createSilentLog() : ui2.log;
   if (!isGitRepo()) {
-    throw new Error("Not a git repository.");
+    log.error("Not a git repository.");
+    process.exit(1);
+  }
+  const config2 = getConfig();
+  const excludes = [...config2.excludes ?? [], ...args.exclude];
+  const guardResult = await runBranchGuard(
+    {
+      allowProtected: !!(args.allowProtected || config2.branch?.allowProtected),
+      autoBranch: !!args.autoBranch,
+      hookMode: !!args.hookMode,
+      apiKey: apiKeyFlag ?? getApiKey() ?? void 0,
+      model: args.model,
+      excludes
+    },
+    log
+  );
+  if (guardResult.action === "abort") {
+    return;
+  }
+  if (guardResult.action === "done") {
+    return;
+  }
+  const _exhaustive = guardResult.action;
+  void _exhaustive;
+  if (all || config2.autoStage) {
+    stageAll();
+    const { files, total } = getShortStagedFiles();
+    const fileList = total > 3 ? `${files.join(", ")}, +${total - 3} more` : files.join(", ");
+    log.step(`staging working tree (${total} file(s))...`);
+    if (fileList) log.dim(`  ${fileList}`);
   }
   if (!hasStagedChanges()) {
-    throw new Error("No staged changes. Stage files with `git add` first.");
+    const unstaged = getUnstagedFiles();
+    if (unstaged.length > 0) {
+      log.error("No staged changes. Use `qc -a` to stage tracked files, or `git add` manually.");
+    } else {
+      log.error("No changes to commit.");
+    }
+    process.exit(1);
   }
-  const local = getLocalProviderConfig();
-  if (!local) {
-    throw new Error(
-      "No local provider configured. Set provider in ~/.config/qc/config.json or run with SaaS (qc login)."
-    );
+  const apiKey = apiKeyFlag ?? getApiKey();
+  if (!apiKey) {
+    log.error("Not authenticated. Run `qc login` first.");
+    process.exit(1);
   }
-  const config2 = getConfig();
-  const excludes = config2.excludes ?? [];
+  const model = modelFlag ?? config2.model;
   const diff = getStagedDiff(excludes);
   const changes = getStagedFiles();
-  const model = modelFlag ?? local.model;
-  let rules = config2.rules ?? {};
+  let processedDiff = diff;
+  if (!args.noSmartDiff) {
+    const smartResult = preprocessDiffWithSizeBudget(diff, 5 * 1024 * 1024);
+    processedDiff = smartResult.processedDiff;
+    if (smartResult.summarized.length > 0) {
+      log.step(
+        `smart-diff: ${smartResult.summarized.length} file(s) summarized (saved ~${Math.round(smartResult.tokensSaved / 1e3)}K tokens)`
+      );
+    }
+    if (smartResult.aggressivelySummarized.length > 0) {
+      log.step(
+        `large-diff: ${smartResult.aggressivelySummarized.length} additional file(s) summarized to fit (commit message may be less specific \u2014 consider committing fewer files at a time)`
+      );
+    }
+  }
+  const commitlintRules = await detectCommitlintRules();
+  let rules = { ...commitlintRules, ...config2.rules ?? {} };
   const workspace = detectWorkspace();
+  let monorepoScopes;
   if (workspace) {
     const stagedFiles = changes.trim().split("\n").filter(Boolean);
     const scope = autoDetectScope(stagedFiles, workspace);
     if (scope) {
-      const scopes = scope.split(",").map((s) => s.trim());
-      rules = { ...rules, scopes };
+      monorepoScopes = scope.split(",").map((s) => s.trim());
+      rules = { ...rules, scopes: monorepoScopes };
     }
   }
-  const userContent = buildUserPrompt(changes, diff, rules);
-  const { url, body, headers } = buildRequest(
-    local.provider,
-    local.baseUrl,
-    userContent,
-    diff,
-    changes,
-    model,
-    local.apiKey,
-    rules
-  );
-  if (!url || url.includes("YOUR-WORKER")) {
-    throw new Error(
-      "Cloudflare provider requires api_url. Run: qc config set api_url https://your-worker.workers.dev"
-    );
-  }
-  const res = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Provider error (${res.status}): ${text}`);
+  const client = new ApiClient({ apiKey });
+  try {
+    const teamRules = await client.getTeamRules();
+    if (teamRules && Object.keys(teamRules).length > 0) {
+      log.step("using team rules from org");
+      rules = { ...rules, ...teamRules };
+      if (monorepoScopes && teamRules.scopes && teamRules.scopes.length > 0) {
+        const allowed = new Set(teamRules.scopes);
+        const intersected = monorepoScopes.filter((s) => allowed.has(s));
+        if (intersected.length > 0) rules = { ...rules, scopes: intersected };
+      }
+    }
+  } catch {
   }
-  const data = await res.json();
-  let message = parseResponse(local.provider, data);
-  message = message.replace(/\\n/g, "\n").replace(/\\r/g, "").trim();
-  if (!message) {
-    throw new Error("Failed to generate commit message.");
+  rules = applyCliTypeScopeToRules(rules, args.type, args.scope);
+  const recentCommits = args.noContext ? void 0 : getRecentBranchCommits(5);
+  const generationHints = generationHintsFromArgs(args.split, args.forceBody);
+  const skipInteractive = silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
+  const skipConfirm = args.dryRun || messageOnly || silent || args.quiet || shouldSkipTTYInteraction(args.hookMode);
+  const modelDisplay = model ?? "default";
+  const spinner = ui2.spinner(`generating commit (${modelDisplay})...`);
+  if (!silent) spinner.start();
+  const t0 = Date.now();
+  let generatedMessage;
+  let diagnostics;
+  try {
+    ({ message: generatedMessage, diagnostics } = await client.generateCommit(
+      processedDiff,
+      changes,
+      rules,
+      model,
+      recentCommits,
+      generationHints
+    ));
+  } finally {
+    spinner.stop();
+  }
+  const roundTripMs = Date.now() - t0;
+  logVerboseDiagnostics((msg) => log.dim(msg), args.verbose, args.quiet, diagnostics, roundTripMs);
+  let message = generatedMessage;
+  if (args.interactive) {
+    if (shouldSkipTTYInteraction(args.hookMode)) {
+      if (!silent) log.dim("(--interactive ignored: not running in a TTY)");
+    } else {
+      const refineResult = await interactiveRefineMessage(message, { skip: skipInteractive });
+      if (refineResult.action === "abort") {
+        return;
+      }
+      message = refineResult.message;
+    }
   }
   if (messageOnly) {
     console.log(message);
     return;
   }
+  const stagedPaths = changes.trim().split("\n").filter(Boolean);
+  const short = getStagedDiffShortstat();
+  const tokenEst = diagnostics && typeof diagnostics === "object" && diagnostics !== null && "tokenUsage" in diagnostics ? diagnostics.tokenUsage?.totalEstimated : void 0;
+  displayCommitMessage(message, {
+    log,
+    isColor: ui2.isColor,
+    isTTY: !!process.stderr.isTTY,
+    style: "rich",
+    stagedFiles: stagedPaths,
+    stats: {
+      files: stagedPaths.length,
+      additions: short.additions,
+      deletions: short.deletions,
+      ...tokenEst !== void 0 ? { tokens: tokenEst } : {}
+    }
+  });
+  if (args.dryRun) {
+    return;
+  }
+  if (args.confirm) {
+    const confirmResult = await confirmCommit("Proceed with commit? [y/N]: ", { skip: skipConfirm });
+    if (confirmResult.action === "abort") {
+      return;
+    }
+  }
   gitCommit(message);
+  const hash = getCommitHash();
+  const branch = getCurrentBranch();
+  log.step(`[${branch} ${hash}] committed`);
   if (push) {
+    log.step(`pushing to origin/${branch}...`);
     gitPush();
+    const stats = getPushStats();
+    if (stats) {
+      log.success(`pushed ${stats.commits} commit(s) \xB7 ${stats.stat}`);
+    } else {
+      log.success("pushed");
+    }
   }
 }
-var import_fs10, import_path10, import_os4, CONFIG_PATH2, PROVIDER_URLS, DEFAULT_MODELS;
-var init_local = __esm({
-  "src/local.ts"() {
+var init_commit = __esm({
+  "src/commands/commit.ts"() {
     "use strict";
-    import_fs10 = require("fs");
-    import_path10 = require("path");
-    import_os4 = require("os");
     init_config();
-    init_dist();
+    init_api();
+    init_commitlint();
     init_git();
     init_monorepo();
-    CONFIG_PATH2 = (0, import_path10.join)((0, import_os4.homedir)(), CONFIG_DIR);
-    PROVIDER_URLS = {
-      ollama: "http://localhost:11434",
-      lmstudio: "http://localhost:1234/v1",
-      openrouter: "https://openrouter.ai/api/v1",
-      custom: "",
-      cloudflare: ""
-    };
-    DEFAULT_MODELS = {
-      ollama: "codellama",
-      lmstudio: "default",
-      openrouter: "google/gemini-flash-1.5-8b",
-      custom: "",
-      cloudflare: "@cf/qwen/qwen2.5-coder-32b-instruct"
-    };
+    init_ui();
+    init_smart_diff();
+    init_commit_helpers();
+    init_branch_guard();
   }
 });
 
 // src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  parseArgs: () => parseArgs
+});
+module.exports = __toCommonJS(index_exports);
 init_config();
-init_api();
-init_commitlint();
-init_git();
-init_monorepo();
 var HELP = `Quikcommit - AI-powered conventional commit messages
 
 Usage:
   qc                    Generate commit message and commit (default)
-  qc --message-only     Generate message only, print to stdout
-  qc --push             Commit and push to origin
   qc pr                 Generate PR description from branch commits
   qc changelog          Generate changelog from commits since last tag
   qc changeset          Automate pnpm changeset with AI
-  qc init               Install prepare-commit-msg hook for auto-generation
+  qc branch             Generate branch name + create branch (use --message for description)
+  qc init               Install prepare-commit-msg hook
   qc login              Sign in via browser
   qc logout             Clear local credentials
   qc status             Show auth, plan, usage
   qc team               Team management (info, rules, invite)
+  qc config             Show/set config
+
+Flags:
+  -p, --push            Commit and push
+  -a, --all             Stage all tracked changes first
+  -m, --message-only    Print message only (stdout, no commit)
+  -v, --verbose         Show diagnostics (model, token estimates, rules) + API round-trip ms on stderr
+  -q, --quiet           Minimal output
+  -n, --dry-run         Show message without committing
+  -i, --interactive     Interactive refinement mode
+  -s, --split           Multi-commit split mode
+  -b, --body            Force include body
+  -l, --local           Use local provider
+  -c, --confirm         Ask before committing
+  -t, --type <type>     Force commit type
+  -S, --scope <scope>   Force scope
+  -e, --exclude <pat>   Exclude files from diff (repeatable)
+
+  --no-context          Skip commit history context
+  --no-smart-diff       Skip smart diff preprocessing
+  --no-color            Disable colors
+  --model <id>          Use specific model
+  --base <branch>       Base branch for pr/changeset (default: main)
+  --create              Create PR with gh CLI (qc pr --create)
+  --from <ref>          Start ref for changelog / base ref for qc branch
+  --to <ref>            End ref for changelog
+  --write               Write changelog to CHANGELOG.md
+  --hook-mode           Silent mode for git hooks
+
+Branch flags (qc branch):
+  --message <text>      Generate from a description (no diff needed)
+  --from-commits        Generate from recent commits instead of diff
+  --rescue              Move commits off current protected branch (see docs)
+  --no-switch           Create branch but don't checkout
+  --from <ref>          Create branch from this ref (default: HEAD)
+
+Commit guard flags:
+  --allow-protected     Bypass protected-branch guard for this run
+  --auto-branch         Auto-create branch with generated name (no prompt)
+
+Compose short flags: qc -ap (stage all + push), qc -apv (+ verbose)
 
-Options:
-  -h, --help            Show this help
-  -a, --all             Stage all tracked changes before generating
-  -m, --message-only    Generate message only
-  -p, --push            Commit and push after generating
-  --api-key <key>       Use this API key (overrides credentials file)
-  --base <branch>       Base branch for qc pr, qc changeset (default: main)
-  --create              Create PR with gh CLI after qc pr
-  --from <ref>          Start ref for qc changelog (default: latest tag)
-  --to <ref>            End ref for qc changelog (default: HEAD)
-  --write               Prepend changelog to CHANGELOG.md
-  --version <ver>       Version label for changelog header (default: derived from --to or "<from>-next")
-  --uninstall           Remove Quikcommit hook (qc init --uninstall)
-  --model <id>          Use specific model (e.g. qwen25-coder-32b, llama-3.3-70b)
-
-Commands:
-  qc config             Show current config
-  qc config set <k> <v> Set config (model, api_url)
-  qc config reset       Reset to defaults
-  qc upgrade            Open billing page in browser
+Examples:
+  qc                    # generate and commit
+  qc -p                 # commit and push
+  qc -ap               # stage all, commit, push
+  qc -m | pbcopy       # copy message to clipboard
+  qc -n                 # preview without committing
+  qc -e "*.lock"       # exclude lock files
+  qc -t fix -S auth    # force type and scope
 `;
+var SHORT_FLAGS = {
+  p: "push",
+  a: "all",
+  m: "messageOnly",
+  v: "verbose",
+  q: "quiet",
+  n: "dryRun",
+  i: "interactive",
+  s: "split",
+  b: "forceBody",
+  l: "local",
+  c: "confirm"
+};
+var SHORT_FLAGS_WITH_VALUE = {
+  t: "type",
+  S: "scope",
+  e: "exclude"
+};
 function parseArgs(args) {
-  let command = "commit";
-  let all = false;
-  let messageOnly = false;
-  let push = false;
-  let apiKey;
-  let model;
-  let local = false;
-  let base;
-  let create = false;
-  let from;
-  let to;
-  let write = false;
-  let version;
-  let uninstall = false;
-  let hookMode = false;
+  const result = {
+    command: "commit",
+    all: false,
+    messageOnly: false,
+    push: false,
+    verbose: false,
+    quiet: false,
+    dryRun: false,
+    interactive: false,
+    split: false,
+    forceBody: false,
+    confirm: false,
+    noContext: false,
+    noSmartDiff: false,
+    local: false,
+    exclude: [],
+    positionals: []
+  };
+  let subcommandSeen = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === "-h" || arg === "--help") {
-      command = "help";
-    } else if (arg === "-a" || arg === "--all") {
-      all = true;
-    } else if (arg === "-m" || arg === "--message-only") {
-      messageOnly = true;
-    } else if (arg === "-p" || arg === "--push") {
-      push = true;
+    if (arg === void 0) continue;
+    if (arg.startsWith("-") && !arg.startsWith("--") && arg.length > 2) {
+      const chars = [...arg.slice(1)];
+      for (let j = 0; j < chars.length; j++) {
+        const ch = chars[j];
+        if (!ch) continue;
+        if (SHORT_FLAGS[ch]) {
+          const key = SHORT_FLAGS[ch];
+          result[key] = true;
+        } else if (SHORT_FLAGS_WITH_VALUE[ch]) {
+          if (j < chars.length - 1) {
+            throw new Error(`Flag -${ch} requires a value and must be last in a composed group`);
+          }
+          const val = args[++i];
+          if (!val || val.startsWith("-") && val.length > 1) throw new Error(`Flag -${ch} requires a value`);
+          const key = SHORT_FLAGS_WITH_VALUE[ch];
+          if (key === "exclude") {
+            result.exclude.push(val);
+          } else {
+            result[key] = val;
+          }
+        } else if (ch === "h") {
+          result.command = "help";
+        } else {
+          throw new Error(`Unknown flag: -${ch}`);
+        }
+      }
+      continue;
+    }
+    if (arg.length === 2 && arg.startsWith("-") && !arg.startsWith("--")) {
+      const ch = arg[1];
+      if (!ch) continue;
+      if (SHORT_FLAGS[ch]) {
+        result[SHORT_FLAGS[ch]] = true;
+        continue;
+      }
+      if (SHORT_FLAGS_WITH_VALUE[ch]) {
+        const val = args[++i];
+        if (!val || val.startsWith("-") && val.length > 1) {
+          throw new Error(`Flag -${ch} requires a value`);
+        }
+        const key = SHORT_FLAGS_WITH_VALUE[ch];
+        if (key === "exclude") {
+          result.exclude.push(val);
+        } else {
+          result[key] = val;
+        }
+        continue;
+      }
+      if (ch === "h") {
+        result.command = "help";
+        continue;
+      }
+      throw new Error(`Unknown flag: -${ch}`);
+    }
+    if (arg === "--help") {
+      result.command = "help";
+    } else if (arg === "--all") {
+      result.all = true;
+    } else if (arg === "--allow-protected") {
+      result.allowProtected = true;
+    } else if (arg === "--auto-branch") {
+      result.autoBranch = true;
+    } else if (arg === "--message-only") {
+      result.messageOnly = true;
+    } else if (arg === "--message" && i + 1 < args.length) {
+      result.message = args[++i];
+    } else if (arg === "--push") {
+      result.push = true;
+    } else if (arg === "--rescue") {
+      result.rescue = true;
+    } else if (arg === "--verbose") {
+      result.verbose = true;
+    } else if (arg === "--quiet") {
+      result.quiet = true;
+    } else if (arg === "--dry-run") {
+      result.dryRun = true;
+    } else if (arg === "--interactive") {
+      result.interactive = true;
+    } else if (arg === "--split") {
+      result.split = true;
+    } else if (arg === "--body") {
+      result.forceBody = true;
+    } else if (arg === "--confirm") {
+      result.confirm = true;
+    } else if (arg === "--no-confirm") {
+      result.confirm = false;
+    } else if (arg === "--no-context") {
+      result.noContext = true;
+    } else if (arg === "--no-smart-diff") {
+      result.noSmartDiff = true;
+    } else if (arg === "--no-switch") {
+      result.noSwitch = true;
+    } else if (arg === "--local" || arg === "--use-ollama" || arg === "--use-lmstudio" || arg === "--use-openrouter" || arg === "--use-cloudflare") {
+      result.local = true;
+      if (arg === "--use-ollama") {
+        result.setProvider = "ollama";
+      } else if (arg === "--use-lmstudio") {
+        result.setProvider = "lmstudio";
+      } else if (arg === "--use-openrouter") {
+        result.setProvider = "openrouter";
+      } else if (arg === "--use-cloudflare") {
+        result.setProvider = "cloudflare";
+      }
     } else if (arg === "--api-key" && i + 1 < args.length) {
-      apiKey = args[++i];
+      result.apiKey = args[++i];
     } else if (arg === "--base" && i + 1 < args.length) {
-      base = args[++i];
+      result.base = args[++i];
     } else if (arg === "--create") {
-      create = true;
+      result.create = true;
     } else if (arg === "--from" && i + 1 < args.length) {
-      from = args[++i];
+      result.from = args[++i];
+    } else if (arg === "--from-commits") {
+      result.fromCommits = true;
     } else if (arg === "--to" && i + 1 < args.length) {
-      to = args[++i];
+      result.to = args[++i];
     } else if (arg === "--write") {
-      write = true;
+      result.write = true;
     } else if (arg === "--version" && i + 1 < args.length) {
-      version = args[++i];
+      result.version = args[++i];
     } else if (arg === "--uninstall") {
-      uninstall = true;
+      result.uninstall = true;
     } else if (arg === "--hook-mode") {
-      hookMode = true;
+      result.hookMode = true;
+    } else if (arg === "--model" && i + 1 < args.length) {
+      result.model = args[++i];
+    } else if (arg === "--type" && i + 1 < args.length) {
+      result.type = args[++i];
+    } else if (arg === "--scope" && i + 1 < args.length) {
+      result.scope = args[++i];
+    } else if (arg === "--exclude" && i + 1 < args.length) {
+      const ex = args[++i];
+      if (ex) result.exclude.push(ex);
+    } else if (arg === "--no-color") {
     } else if (arg === "login") {
-      command = "login";
+      result.command = "login";
+      subcommandSeen = true;
     } else if (arg === "logout") {
-      command = "logout";
+      result.command = "logout";
+      subcommandSeen = true;
     } else if (arg === "status") {
-      command = "status";
+      result.command = "status";
+      subcommandSeen = true;
     } else if (arg === "pr") {
-      command = "pr";
+      result.command = "pr";
+      subcommandSeen = true;
     } else if (arg === "changelog") {
-      command = "changelog";
+      result.command = "changelog";
+      subcommandSeen = true;
+    } else if (arg === "branch") {
+      result.command = "branch";
+      subcommandSeen = true;
     } else if (arg === "init") {
-      command = "init";
+      result.command = "init";
+      subcommandSeen = true;
     } else if (arg === "team") {
-      command = "team";
+      result.command = "team";
+      subcommandSeen = true;
     } else if (arg === "config") {
-      command = "config";
+      result.command = "config";
+      subcommandSeen = true;
     } else if (arg === "upgrade") {
-      command = "upgrade";
+      result.command = "upgrade";
+      subcommandSeen = true;
     } else if (arg === "changeset") {
-      command = "changeset";
-    } else if (arg === "--model" && i + 1 < args.length) {
-      model = args[++i];
-    } else if (arg === "--local" || arg === "--use-ollama" || arg === "--use-lmstudio" || arg === "--use-openrouter" || arg === "--use-cloudflare") {
-      local = true;
-      if (arg === "--use-ollama") {
-        saveConfig({ ...getConfig(), provider: "ollama", apiUrl: "http://localhost:11434", model: "codellama" });
-      } else if (arg === "--use-lmstudio") {
-        saveConfig({ ...getConfig(), provider: "lmstudio", apiUrl: "http://localhost:1234/v1", model: "default" });
-      } else if (arg === "--use-openrouter") {
-        saveConfig({ ...getConfig(), provider: "openrouter", apiUrl: "https://openrouter.ai/api/v1", model: "google/gemini-flash-1.5-8b" });
-      } else if (arg === "--use-cloudflare") {
-        saveConfig({
-          ...getConfig(),
-          provider: "cloudflare",
-          apiUrl: "https://YOUR-WORKER.workers.dev",
-          model: "@cf/qwen/qwen2.5-coder-32b-instruct"
-        });
-        console.error(
-          "[qc] Cloudflare provider set. Run: qc config set api_url https://your-worker.workers.dev"
-        );
-      }
-    }
-  }
-  return { command, all, messageOnly, push, apiKey, base, create, from, to, write, version, uninstall, hookMode, model, local };
-}
-async function runCommit(messageOnly, push, apiKeyFlag, hookMode = false, modelFlag, stageAll_) {
-  const log = hookMode ? () => {
-  } : (msg) => console.error(msg);
-  if (!isGitRepo()) {
-    log("Error: Not a git repository.");
-    process.exit(1);
-  }
-  const config2 = getConfig();
-  if (stageAll_ || config2.autoStage) {
-    stageAll();
-  }
-  if (!hasStagedChanges()) {
-    const unstaged = getUnstagedFiles();
-    if (unstaged.length > 0) {
-      log("Error: No staged changes. Use `qc -a` to stage tracked files, or `git add` manually.");
-    } else {
-      log("Error: No changes to commit.");
-    }
-    process.exit(1);
-  }
-  const apiKey = apiKeyFlag ?? getApiKey();
-  if (!apiKey) {
-    log("Error: Not authenticated. Run `qc login` first.");
-    process.exit(1);
-  }
-  const model = modelFlag ?? config2.model;
-  const excludes = config2.excludes ?? [];
-  const diff = getStagedDiff(excludes);
-  const changes = getStagedFiles();
-  const commitlintRules = await detectCommitlintRules();
-  let rules = { ...commitlintRules, ...config2.rules ?? {} };
-  const workspace = detectWorkspace();
-  let monorepoScopes;
-  if (workspace) {
-    const stagedFiles = changes.trim().split("\n").filter(Boolean);
-    const scope = autoDetectScope(stagedFiles, workspace);
-    if (scope) {
-      monorepoScopes = scope.split(",").map((s) => s.trim());
-      rules = { ...rules, scopes: monorepoScopes };
+      result.command = "changeset";
+      subcommandSeen = true;
+    } else if (subcommandSeen && !arg.startsWith("-")) {
+      result.positionals.push(arg);
     }
   }
-  const client = new ApiClient({ apiKey });
-  try {
-    const teamRules = await client.getTeamRules();
-    if (teamRules && Object.keys(teamRules).length > 0) {
-      log("[qc] Using team rules from org");
-      rules = { ...rules, ...teamRules };
-      if (monorepoScopes && teamRules.scopes && teamRules.scopes.length > 0) {
-        const allowed = new Set(teamRules.scopes);
-        const intersected = monorepoScopes.filter((s) => allowed.has(s));
-        if (intersected.length > 0) rules = { ...rules, scopes: intersected };
-      }
-    }
-  } catch {
+  if (result.messageOnly && result.push) {
+    throw new Error("Cannot combine --message-only (-m) with --push (-p)");
   }
-  const { message } = await client.generateCommit(diff, changes, rules, model);
-  if (messageOnly) {
-    console.log(message);
-    return;
+  if (result.quiet && result.verbose) {
+    throw new Error("Cannot combine --quiet (-q) with --verbose (-v)");
   }
-  gitCommit(message);
-  if (push) {
-    gitPush();
+  if (result.dryRun && result.push) {
+    throw new Error("Cannot combine --dry-run (-n) with --push (-p). Pick one.");
   }
+  return result;
 }
 async function main() {
   const argv = process.argv.slice(2);
-  const values = parseArgs(argv);
-  const { command, messageOnly, push, apiKey } = values;
+  let values;
+  try {
+    values = parseArgs(argv);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const { command, apiKey } = values;
   if (command === "help") {
     console.log(HELP);
     return;
   }
+  if (values.setProvider) {
+    switch (values.setProvider) {
+      case "ollama":
+        saveConfig({ ...getConfig(), provider: "ollama", apiUrl: "http://localhost:11434", model: "codellama" });
+        break;
+      case "lmstudio":
+        saveConfig({ ...getConfig(), provider: "lmstudio", apiUrl: "http://localhost:1234/v1", model: "default" });
+        break;
+      case "openrouter":
+        saveConfig({
+          ...getConfig(),
+          provider: "openrouter",
+          apiUrl: "https://openrouter.ai/api/v1",
+          model: "google/gemini-flash-1.5-8b"
+        });
+        break;
+      case "cloudflare":
+        saveConfig({
+          ...getConfig(),
+          provider: "cloudflare",
+          apiUrl: "https://YOUR-WORKER.workers.dev",
+          model: "@cf/qwen/qwen2.5-coder-32b-instruct"
+        });
+        console.error("[qc] Cloudflare provider set. Run: qc config set api_url https://your-worker.workers.dev");
+        break;
+    }
+  }
   if (command === "login") {
     const { runLogin: runLogin2 } = await Promise.resolve().then(() => (init_login(), login_exports));
     await runLogin2();
@@ -9526,6 +11587,23 @@ async function main() {
     });
     return;
   }
+  if (command === "branch") {
+    const { runBranch: runBranch2 } = await Promise.resolve().then(() => (init_branch2(), branch_exports));
+    const explicitName = values.positionals[0];
+    await runBranch2({
+      explicitName,
+      message: values.message,
+      fromCommits: values.fromCommits,
+      rescue: values.rescue,
+      dryRun: values.dryRun,
+      noSwitch: values.noSwitch,
+      push: values.push,
+      from: values.from,
+      model: values.model,
+      apiKey: values.apiKey
+    });
+    return;
+  }
   if (command === "init") {
     const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
     init2({ uninstall: values.uninstall });
@@ -9533,14 +11611,12 @@ async function main() {
   }
   if (command === "team") {
     const { team: team2 } = await Promise.resolve().then(() => (init_team(), team_exports));
-    const positionals = argv.filter((a) => !a.startsWith("-") && a !== "team");
-    await team2(positionals[0], positionals.slice(1));
+    await team2(values.positionals[0], values.positionals.slice(1));
     return;
   }
   if (command === "config") {
-    const { config: config2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
-    const positionals = argv.filter((a) => !a.startsWith("-") && a !== "config");
-    config2(positionals);
+    const { config: config2 } = await Promise.resolve().then(() => (init_config2(), config_exports2));
+    config2(values.positionals);
     return;
   }
   if (command === "upgrade") {
@@ -9550,7 +11626,7 @@ async function main() {
   }
   if (values.local) {
     const { runLocalCommit: runLocalCommit2 } = await Promise.resolve().then(() => (init_local(), local_exports));
-    await runLocalCommit2(messageOnly, push, values.model);
+    await runLocalCommit2(values);
     return;
   }
   const apiKeyToUse = apiKey ?? getApiKey();
@@ -9558,11 +11634,12 @@ async function main() {
     const { getLocalProviderConfig: getLocalProviderConfig2 } = await Promise.resolve().then(() => (init_local(), local_exports));
     if (getLocalProviderConfig2()) {
       const { runLocalCommit: runLocalCommit2 } = await Promise.resolve().then(() => (init_local(), local_exports));
-      await runLocalCommit2(messageOnly, push, values.model);
+      await runLocalCommit2(values);
       return;
     }
   }
-  await runCommit(messageOnly, push, apiKey, values.hookMode, values.model, values.all);
+  const { runCommit: runCommit2 } = await Promise.resolve().then(() => (init_commit(), commit_exports));
+  await runCommit2(values);
 }
 main().catch((err) => {
   const args = process.argv.slice(2);
@@ -9572,3 +11649,7 @@ main().catch((err) => {
   }
   process.exit(1);
 });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseArgs
+});