@quikcommit/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1583 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../shared/dist/types.js
+var init_types = __esm({
+  "../shared/dist/types.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/constants.js
+var CONFIG_DIR, CREDENTIALS_FILE, CONFIG_FILE, DEFAULT_API_URL, DEVICE_POLL_INTERVAL, DEVICE_FLOW_TIMEOUT;
+var init_constants = __esm({
+  "../shared/dist/constants.js"() {
+    "use strict";
+    CONFIG_DIR = ".config/qc";
+    CREDENTIALS_FILE = "credentials";
+    CONFIG_FILE = "config.json";
+    DEFAULT_API_URL = "https://api.quikcommit.dev";
+    DEVICE_POLL_INTERVAL = 2e3;
+    DEVICE_FLOW_TIMEOUT = 6e5;
+  }
+});
+
+// ../shared/dist/rules.js
+var init_rules = __esm({
+  "../shared/dist/rules.js"() {
+    "use strict";
+  }
+});
+
+// ../shared/dist/index.js
+var init_dist = __esm({
+  "../shared/dist/index.js"() {
+    "use strict";
+    init_types();
+    init_constants();
+    init_rules();
+  }
+});
+
+// src/config.ts
+function getApiKey() {
+  const envKey = process.env.QC_API_KEY;
+  if (envKey?.trim()) return envKey.trim();
+  try {
+    if ((0, import_fs.existsSync)(CREDENTIALS_PATH)) {
+      return (0, import_fs.readFileSync)(CREDENTIALS_PATH, "utf-8").trim() || null;
+    }
+  } catch {
+  }
+  return null;
+}
+function saveApiKey(key) {
+  (0, import_fs.mkdirSync)(CONFIG_PATH, { recursive: true, mode: 448 });
+  (0, import_fs.writeFileSync)(CREDENTIALS_PATH, key.trim(), { mode: 384 });
+}
+function clearApiKey() {
+  try {
+    if ((0, import_fs.existsSync)(CREDENTIALS_PATH)) {
+      (0, import_fs.unlinkSync)(CREDENTIALS_PATH);
+    }
+  } catch {
+  }
+}
+function getConfig() {
+  try {
+    if ((0, import_fs.existsSync)(CONFIG_JSON_PATH)) {
+      const raw = (0, import_fs.readFileSync)(CONFIG_JSON_PATH, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return {};
+}
+function saveConfig(config2) {
+  (0, import_fs.mkdirSync)(CONFIG_PATH, { recursive: true, mode: 448 });
+  (0, import_fs.writeFileSync)(CONFIG_JSON_PATH, JSON.stringify(config2, null, 2), {
+    mode: 384
+  });
+}
+var import_fs, import_path, import_os, CONFIG_PATH, CREDENTIALS_PATH, CONFIG_JSON_PATH;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    import_os = require("os");
+    init_dist();
+    CONFIG_PATH = (0, import_path.join)((0, import_os.homedir)(), CONFIG_DIR);
+    CREDENTIALS_PATH = (0, import_path.join)(CONFIG_PATH, CREDENTIALS_FILE);
+    CONFIG_JSON_PATH = (0, import_path.join)(CONFIG_PATH, CONFIG_FILE);
+  }
+});
+
+// src/api.ts
+var ApiClient;
+var init_api = __esm({
+  "src/api.ts"() {
+    "use strict";
+    init_config();
+    init_dist();
+    ApiClient = class {
+      apiKey;
+      baseUrl;
+      constructor(options = {}) {
+        this.apiKey = options.apiKey ?? getApiKey();
+        this.baseUrl = options.baseUrl ?? process.env.QC_API_URL ?? DEFAULT_API_URL;
+      }
+      hasAuth() {
+        return !!this.apiKey?.trim();
+      }
+      async request(endpoint, body, planRequiredMsg) {
+        if (!this.apiKey) {
+          throw new Error("Not authenticated. Run `qc login` first.");
+        }
+        const res = await fetch(`${this.baseUrl}${endpoint}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: JSON.stringify(body)
+        });
+        if (!res.ok) {
+          const err = await res.json().catch(() => ({ error: res.statusText }));
+          const code = err.code;
+          if (planRequiredMsg && code === "PLAN_REQUIRED") {
+            throw new Error(planRequiredMsg);
+          }
+          throw new Error(err.error ?? `HTTP ${res.status}`);
+        }
+        return res.json();
+      }
+      async generateCommit(diff, changes, rules, model) {
+        const body = { diff, changes, rules, model };
+        const data = await this.request(
+          "/v1/commit",
+          body
+        );
+        return { message: data.message ?? "", diagnostics: data.diagnostics };
+      }
+      async generatePR(req, model) {
+        const data = await this.request(
+          "/v1/pr",
+          { ...req, model },
+          "PR descriptions require Pro plan. Upgrade at https://app.quikcommit.dev/billing"
+        );
+        return { message: data.message ?? "" };
+      }
+      async generateChangelog(req, model) {
+        const data = await this.request(
+          "/v1/changelog",
+          { ...req, model },
+          "Changelog generation requires Pro plan. Upgrade at https://app.quikcommit.dev/billing"
+        );
+        return { message: data.message ?? "" };
+      }
+      async fetchJson(endpoint, options) {
+        if (!this.apiKey) {
+          throw new Error("Not authenticated. Run `qc login` first.");
+        }
+        const res = await fetch(`${this.baseUrl}${endpoint}`, {
+          method: options?.method ?? "GET",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`
+          },
+          body: options?.body
+        });
+        if (!res.ok) {
+          const err = await res.json().catch(() => ({ error: res.statusText }));
+          throw new Error(err.error ?? `HTTP ${res.status}`);
+        }
+        return res.json();
+      }
+      async getTeam() {
+        return this.fetchJson("/v1/team");
+      }
+      async getTeamRules() {
+        return this.fetchJson("/v1/team/rules");
+      }
+      async pushTeamRules(rules) {
+        await this.fetchJson("/v1/team/rules", {
+          method: "PUT",
+          body: JSON.stringify(rules)
+        });
+      }
+      async inviteTeamMember(email) {
+        await this.fetchJson("/v1/team/invite", {
+          method: "POST",
+          body: JSON.stringify({ email })
+        });
+      }
+      async getUsage() {
+        if (!this.apiKey) return null;
+        const res = await fetch(`${this.baseUrl}/v1/usage`, {
+          headers: { Authorization: `Bearer ${this.apiKey}` }
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        return {
+          plan: data.plan ?? "free",
+          commit_count: data.commit_count ?? 0,
+          limit: data.limit ?? 50,
+          remaining: data.remaining ?? 50
+        };
+      }
+    };
+  }
+});
+
+// src/git.ts
+function validateRef(ref, name = "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"], {
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitRoot() {
+  try {
+    return (0, import_child_process.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+function getStagedDiff(excludes = []) {
+  const args = ["diff", "--cached"];
+  if (excludes.length > 0) {
+    args.push("--");
+    args.push(".");
+    for (const pattern of excludes) {
+      args.push(`:(exclude)${pattern}`);
+    }
+  }
+  return (0, import_child_process.execFileSync)("git", args, {
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+}
+function getStagedFiles() {
+  return (0, import_child_process.execFileSync)("git", ["diff", "--cached", "--name-only"], {
+    encoding: "utf-8"
+  });
+}
+function hasStagedChanges() {
+  const output = (0, import_child_process.execFileSync)("git", ["diff", "--cached", "--name-only"], {
+    encoding: "utf-8"
+  });
+  return output.trim().length > 0;
+}
+function gitCommit(message) {
+  const tmpDir = (0, import_fs2.mkdtempSync)((0, import_path2.join)((0, import_os2.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" });
+  } finally {
+    try {
+      (0, import_fs2.unlinkSync)(tmpFile);
+      (0, import_fs2.rmdirSync)(tmpDir);
+    } catch {
+    }
+  }
+}
+function gitPush() {
+  (0, import_child_process.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"], {
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return output.trim().split("\n").filter(Boolean);
+}
+function getDiffStat(base = "main") {
+  validateRef(base, "base");
+  return (0, import_child_process.execFileSync)("git", ["diff", `${base}..HEAD`, "--stat"], {
+    encoding: "utf-8",
+    maxBuffer: 10 * 1024 * 1024
+  });
+}
+function getLatestTag() {
+  try {
+    return (0, import_child_process.execFileSync)("git", ["describe", "--tags", "--abbrev=0"], {
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function getCommitsSince(ref, to = "HEAD") {
+  validateRef(ref, "from ref");
+  validateRef(to, "to ref");
+  const output = (0, import_child_process.execFileSync)(
+    "git",
+    ["log", `${ref}..${to}`, "--format=%H %s", "--max-count=1000"],
+    { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+  );
+  return output.trim().split("\n").filter(Boolean).map((line) => {
+    const [hash, ...rest] = line.split(" ");
+    return { hash: hash ?? "", subject: rest.join(" ").trim() };
+  });
+}
+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/monorepo.ts
+function findGitRoot(start) {
+  try {
+    return (0, import_child_process2.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+      encoding: "utf-8",
+      cwd: start,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return start;
+  }
+}
+function detectWorkspace(cwd = findGitRoot(process.cwd())) {
+  const pnpmWs = (0, import_path3.join)(cwd, "pnpm-workspace.yaml");
+  if ((0, import_fs3.existsSync)(pnpmWs)) {
+    const content = (0, import_fs3.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_path3.join)(cwd, "lerna.json");
+  if ((0, import_fs3.existsSync)(lerna)) {
+    try {
+      const config2 = JSON.parse((0, import_fs3.readFileSync)(lerna, "utf-8"));
+      return {
+        type: "lerna",
+        packages: config2.packages ?? ["packages/*"],
+        root: cwd
+      };
+    } catch {
+    }
+  }
+  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "nx.json"))) {
+    return {
+      type: "nx",
+      packages: ["packages/*", "apps/*", "libs/*"],
+      root: cwd
+    };
+  }
+  if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "turbo.json"))) {
+    const pkgPath2 = (0, import_path3.join)(cwd, "package.json");
+    if ((0, import_fs3.existsSync)(pkgPath2)) {
+      try {
+        const config2 = JSON.parse((0, import_fs3.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 };
+        }
+      } catch {
+      }
+    }
+  }
+  const pkgPath = (0, import_path3.join)(cwd, "package.json");
+  if ((0, import_fs3.existsSync)(pkgPath)) {
+    try {
+      const config2 = JSON.parse((0, import_fs3.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 };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function matchGlobPattern(rel, pattern) {
+  const dir = pattern.replace(/\/?\*\*?$/, "").replace(/\/$/, "");
+  if (!dir || dir === "*" || dir === "**") {
+    const pkg = rel.split("/")[0];
+    return pkg || null;
+  }
+  const starIdx = dir.indexOf("*");
+  if (starIdx !== -1) {
+    const prefix2 = dir.slice(0, starIdx);
+    if (rel.startsWith(prefix2)) {
+      const rest = rel.slice(prefix2.length);
+      const pkg = rest.split("/")[0];
+      return pkg || null;
+    }
+    return null;
+  }
+  const prefix = dir + "/";
+  if (rel.startsWith(prefix)) {
+    const rest = rel.slice(prefix.length);
+    const pkg = rest.split("/")[0];
+    return pkg || null;
+  }
+  return null;
+}
+function getPackageForFile(filePath, workspace) {
+  const absPath = filePath.startsWith("/") ? filePath : (0, import_path3.join)(workspace.root, filePath);
+  const rel = (0, import_path3.relative)(workspace.root, absPath);
+  for (const pattern of workspace.packages) {
+    const packageName = matchGlobPattern(rel, pattern);
+    if (packageName) return packageName;
+  }
+  return null;
+}
+function autoDetectScope(stagedFiles, workspace) {
+  const packages = /* @__PURE__ */ new Set();
+  for (const file of stagedFiles) {
+    const filePath = file.startsWith("/") ? file : (0, import_path3.join)(workspace.root, file);
+    const pkg = getPackageForFile(filePath, workspace);
+    if (pkg) packages.add(pkg);
+  }
+  if (packages.size === 1) return [...packages][0];
+  if (packages.size > 1 && packages.size <= 3) return [...packages].join(",");
+  if (packages.size > 3) {
+    console.error(
+      `[qc] Changes span ${packages.size} packages; skipping auto-scope detection.`
+    );
+  }
+  return null;
+}
+var import_child_process2, import_fs3, import_path3;
+var init_monorepo = __esm({
+  "src/monorepo.ts"() {
+    "use strict";
+    import_child_process2 = require("child_process");
+    import_fs3 = require("fs");
+    import_path3 = 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_process3.execFileSync)("open", [url], { stdio: "pipe" });
+      return true;
+    }
+    if ((0, import_os3.platform)() === "linux") {
+      (0, import_child_process3.execFileSync)("xdg-open", [url], { stdio: "pipe" });
+      return true;
+    }
+    if ((0, import_os3.platform)() === "win32") {
+      (0, import_child_process3.execFileSync)("cmd", ["/c", "start", "", url], { stdio: "pipe" });
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+async function runLogin() {
+  const startRes = await fetch(`${API_URL}/v1/auth/device/start`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({})
+  });
+  if (!startRes.ok) {
+    const err = await startRes.json().catch(() => ({ error: startRes.statusText }));
+    throw new Error(err.error ?? "Failed to start device flow");
+  }
+  const startData = await startRes.json();
+  const code = startData.device_code;
+  if (!code) {
+    throw new Error("Server did not return a device_code");
+  }
+  console.log("Opening browser to sign in...");
+  console.log("");
+  const authUrl = `${DASHBOARD_URL}/auth/cli?code=${encodeURIComponent(code)}`;
+  const opened = openBrowser(authUrl);
+  if (!opened) {
+    console.log("Could not open browser. Please visit:");
+    console.log(authUrl);
+    console.log("");
+  }
+  const startTime = Date.now();
+  while (Date.now() - startTime < DEVICE_FLOW_TIMEOUT) {
+    try {
+      const res = await fetch(
+        `${API_URL}/v1/auth/device/poll?code=${encodeURIComponent(code)}`
+      );
+      const data = await res.json();
+      if (data.status === "complete" && data.api_key) {
+        saveApiKey(data.api_key);
+        console.log("Successfully logged in!");
+        return;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, DEVICE_POLL_INTERVAL));
+  }
+  console.error("Login timed out. Please try again.");
+  process.exit(1);
+}
+var import_child_process3, import_os3, API_URL, DASHBOARD_URL;
+var init_login = __esm({
+  "src/commands/login.ts"() {
+    "use strict";
+    import_child_process3 = 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";
+  }
+});
+
+// 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/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();
+  }
+});
+
+// src/commands/pr.ts
+var pr_exports = {};
+__export(pr_exports, {
+  pr: () => pr
+});
+async function pr(options) {
+  const base = options.base ?? "main";
+  const commits = getBranchCommits(base);
+  const diffStat = getDiffStat(base);
+  if (commits.length === 0) {
+    console.error(`No commits found on this branch vs ${base}`);
+    process.exit(1);
+  }
+  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
+    },
+    options.model
+  );
+  console.log("\n" + result.message + "\n");
+  if (options.create) {
+    try {
+      const title = result.message.split("\n").find((l) => l.trim()) ?? result.message.substring(0, 72).trim();
+      (0, import_child_process4.execFileSync)("gh", ["pr", "create", "--title", title, "--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;
+var init_pr = __esm({
+  "src/commands/pr.ts"() {
+    "use strict";
+    import_child_process4 = require("child_process");
+    init_config();
+    init_api();
+    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_path4.join)(getGitRoot(), "CHANGELOG.md");
+    const existing = (0, import_fs4.existsSync)(path) ? (0, import_fs4.readFileSync)(path, "utf-8") : "";
+    const newContent = changelogEntry + (existing ? "\n\n" + existing : "");
+    (0, import_fs4.writeFileSync)(path, newContent);
+    console.error(`Wrote to ${path}`);
+  } else {
+    console.log(changelogEntry);
+  }
+}
+var import_fs4, import_path4, CONVENTIONAL_TYPE_RE;
+var init_changelog = __esm({
+  "src/commands/changelog.ts"() {
+    "use strict";
+    import_fs4 = require("fs");
+    import_path4 = require("path");
+    init_config();
+    init_api();
+    init_git();
+    CONVENTIONAL_TYPE_RE = /^(feat|fix|docs|style|refactor|perf|test|chore)(\([^)]+\))?!?:\s+/i;
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  init: () => init
+});
+async function init(options) {
+  let hooksDir;
+  try {
+    hooksDir = (0, import_child_process5.execFileSync)("git", ["rev-parse", "--git-path", "hooks"], {
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    console.error("Error: Not a git repository");
+    process.exit(1);
+  }
+  const hookPath = (0, import_path5.join)(hooksDir, "prepare-commit-msg");
+  if (options.uninstall) {
+    if ((0, import_fs5.existsSync)(hookPath)) {
+      const content = (0, import_fs5.readFileSync)(hookPath, "utf-8");
+      if (content.includes("QuikCommit")) {
+        (0, import_fs5.unlinkSync)(hookPath);
+        console.log("QuikCommit hook removed.");
+      } else {
+        console.log("Hook exists but was not installed by QuikCommit. Skipping.");
+      }
+    } else {
+      console.log("No hook to remove.");
+    }
+    return;
+  }
+  if ((0, import_fs5.existsSync)(hookPath)) {
+    const content = (0, import_fs5.readFileSync)(hookPath, "utf-8");
+    if (content.includes("QuikCommit")) {
+      console.log("QuikCommit hook is already installed.");
+      return;
+    }
+    console.error(
+      "A prepare-commit-msg hook already exists. Use --uninstall first or manually merge."
+    );
+    process.exit(1);
+  }
+  (0, import_fs5.writeFileSync)(hookPath, HOOK_CONTENT);
+  (0, import_fs5.chmodSync)(hookPath, 493);
+  console.log("QuikCommit hook installed.");
+  console.log("Now just run `git commit` and a message will be generated automatically.");
+}
+var import_fs5, import_path5, import_child_process5, HOOK_CONTENT;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    import_fs5 = require("fs");
+    import_path5 = require("path");
+    import_child_process5 = require("child_process");
+    HOOK_CONTENT = `#!/bin/sh
+# QuikCommit - auto-generate commit messages
+# Installed by: qc init
+# Remove with: qc init --uninstall
+
+# Only generate if no message was provided (empty commit message file)
+COMMIT_MSG_FILE="$1"
+COMMIT_SOURCE="$2"
+
+# Skip if message was provided via -m, merge, squash, etc.
+if [ -n "$COMMIT_SOURCE" ]; then
+  exit 0
+fi
+
+# Skip if message file already has content (excluding comments)
+if grep -qv '^#' "$COMMIT_MSG_FILE" 2>/dev/null; then
+  if [ -n "$(grep -v '^#' "$COMMIT_MSG_FILE" | grep -v '^$')" ]; then
+    exit 0
+  fi
+fi
+
+# Generate commit message
+MSG=$(qc --message-only --hook-mode 2>/dev/null)
+if [ $? -eq 0 ] && [ -n "$MSG" ]; then
+  printf '%s
+' "$MSG" > "$COMMIT_MSG_FILE"
+fi
+`;
+  }
+});
+
+// src/commands/team.ts
+var team_exports = {};
+__export(team_exports, {
+  team: () => team
+});
+function createApiClient() {
+  return new ApiClient();
+}
+function mapCommitlintToRules(config2) {
+  if (!config2 || typeof config2 !== "object") return null;
+  const c = config2;
+  const rules = {};
+  const ext = c.extends;
+  const rulesConfig = c.rules;
+  if (Array.isArray(rulesConfig?.["type-enum"]) && rulesConfig["type-enum"].length >= 3) {
+    const [, , value] = rulesConfig["type-enum"];
+    if (Array.isArray(value)) rules.types = value;
+  }
+  if (Array.isArray(rulesConfig?.["scope-enum"]) && rulesConfig["scope-enum"].length >= 3) {
+    const [, , value] = rulesConfig["scope-enum"];
+    if (Array.isArray(value)) rules.scopes = value;
+  }
+  if (Array.isArray(rulesConfig?.["header-max-length"]) && rulesConfig["header-max-length"].length >= 3) {
+    const [, , maxLen] = rulesConfig["header-max-length"];
+    if (typeof maxLen === "number") rules.headerMaxLength = maxLen;
+  }
+  if (Array.isArray(rulesConfig?.["subject-case"]) && rulesConfig["subject-case"].length >= 3) {
+    const [, , val] = rulesConfig["subject-case"];
+    if (val != null) rules.subjectCase = Array.isArray(val) ? val : [val];
+  }
+  return Object.keys(rules).length > 0 ? rules : null;
+}
+function detectLocalCommitlintRules() {
+  const cwd = process.cwd();
+  const files = [
+    ".commitlintrc.json",
+    ".commitlintrc",
+    "commitlint.config.js",
+    "commitlint.config.cjs",
+    "commitlint.config.mjs"
+  ];
+  for (const file of files) {
+    const path = (0, import_path6.join)(cwd, file);
+    if (!(0, import_fs6.existsSync)(path)) continue;
+    try {
+      const content = (0, import_fs6.readFileSync)(path, "utf-8");
+      let parsed;
+      if (file.endsWith(".json") || file === ".commitlintrc") {
+        parsed = JSON.parse(content);
+      } else {
+        continue;
+      }
+      const rules = mapCommitlintToRules(parsed);
+      if (rules) return rules;
+    } catch {
+    }
+  }
+  const pkgPath = (0, import_path6.join)(cwd, "package.json");
+  if ((0, import_fs6.existsSync)(pkgPath)) {
+    try {
+      const content = (0, import_fs6.readFileSync)(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.commitlint) {
+        const rules = mapCommitlintToRules(pkg.commitlint);
+        if (rules) return rules;
+      }
+    } catch {
+    }
+  }
+  const config2 = getConfig();
+  if (config2.rules && Object.keys(config2.rules).length > 0) {
+    return config2.rules;
+  }
+  return null;
+}
+async function team(subcommand, args) {
+  const api = createApiClient();
+  switch (subcommand) {
+    case void 0:
+    case "info": {
+      const info = await api.getTeam();
+      console.log(`
+  Team: ${info.name}`);
+      console.log(`  Plan: ${info.plan}`);
+      console.log(`  Members: ${info.member_count}`);
+      console.log("\n  Members:");
+      for (const m of info.members) {
+        console.log(`    ${m.name ?? m.email} <${m.email}> (${m.role})`);
+      }
+      break;
+    }
+    case "rules": {
+      if (args?.[0] === "push") {
+        const rules = detectLocalCommitlintRules();
+        if (!rules) {
+          console.error("No local commitlint config found.");
+          process.exit(1);
+        }
+        await api.pushTeamRules(rules);
+        console.log("Team rules updated from local commitlint config.");
+      } else {
+        const rules = await api.getTeamRules();
+        console.log("\n  Team Commit Rules:");
+        console.log(JSON.stringify(rules, null, 2));
+      }
+      break;
+    }
+    case "invite": {
+      const email = args?.[0];
+      if (!email) {
+        console.error("Usage: qc team invite <email>");
+        process.exit(1);
+      }
+      await api.inviteTeamMember(email);
+      console.log(`Invitation sent to ${email}`);
+      break;
+    }
+    default:
+      console.error(`Unknown team command: ${subcommand}`);
+      console.log("Usage: qc team [info|rules|rules push|invite <email>]");
+      process.exit(1);
+  }
+}
+var import_fs6, import_path6;
+var init_team = __esm({
+  "src/commands/team.ts"() {
+    "use strict";
+    import_fs6 = require("fs");
+    import_path6 = require("path");
+    init_api();
+    init_config();
+  }
+});
+
+// src/commands/config.ts
+var config_exports = {};
+__export(config_exports, {
+  config: () => config
+});
+async function config(args) {
+  if (args.length === 0) {
+    showConfig();
+    return;
+  }
+  const sub = args[0];
+  if (sub === "set") {
+    const key = args[1];
+    const value = args[2];
+    if (!key || !value) {
+      console.error("Usage: qc config set <key> <value>");
+      console.error("  Keys: model, api_url, provider");
+      process.exit(1);
+    }
+    await setConfig(key, value);
+    return;
+  }
+  if (sub === "reset") {
+    resetConfig();
+    return;
+  }
+  console.error(`Unknown subcommand: ${sub}`);
+  console.error("Usage: qc config [set <key> <value> | reset]");
+  process.exit(1);
+}
+function showConfig() {
+  const cfg = getConfig();
+  const apiKey = getApiKey();
+  console.log("Current configuration:");
+  console.log(`  model:    ${cfg.model ?? "(default for plan)"}`);
+  console.log(`  api_url:  ${cfg.apiUrl ?? DEFAULT_API_URL}`);
+  console.log(`  provider: ${cfg.provider ?? "(default)"}`);
+  console.log(`  auth:     ${apiKey ? "****" : "not set"}`);
+  if (cfg.excludes?.length) {
+    console.log(`  excludes: ${cfg.excludes.join(", ")}`);
+  }
+}
+async function setConfig(key, value) {
+  const cfg = getConfig();
+  const updates = {};
+  if (key === "model") {
+    updates.model = value;
+  } else if (key === "provider") {
+    const valid = ["ollama", "lmstudio", "openrouter", "custom", "cloudflare"];
+    if (!valid.includes(value.toLowerCase())) {
+      console.error(`Invalid provider. Must be one of: ${valid.join(", ")}`);
+      process.exit(1);
+    }
+    updates.provider = value.toLowerCase();
+  } else if (key === "api_url") {
+    try {
+      new URL(value);
+      updates.apiUrl = value;
+    } catch {
+      console.error("Invalid URL:", value);
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown key: ${key}`);
+    console.error("  Keys: model, api_url, provider");
+    process.exit(1);
+  }
+  saveConfig({ ...cfg, ...updates });
+  console.log(`Set ${key} = ${value}`);
+}
+function resetConfig() {
+  saveConfig({});
+  console.log("Config reset to defaults.");
+}
+var init_config2 = __esm({
+  "src/commands/config.ts"() {
+    "use strict";
+    init_config();
+    init_dist();
+  }
+});
+
+// src/commands/upgrade.ts
+var upgrade_exports = {};
+__export(upgrade_exports, {
+  upgrade: () => upgrade
+});
+async function upgrade() {
+  console.log(`
+Opening ${BILLING_URL}
+`);
+  try {
+    const { execFileSync: execFileSync6 } = await import("child_process");
+    if (process.platform === "darwin") {
+      execFileSync6("open", [BILLING_URL]);
+    } else if (process.platform === "linux") {
+      execFileSync6("xdg-open", [BILLING_URL]);
+    } else if (process.platform === "win32") {
+      execFileSync6("cmd", ["/c", "start", "", BILLING_URL]);
+    }
+  } catch {
+    console.log(`Visit: ${BILLING_URL}`);
+  }
+}
+var BILLING_URL;
+var init_upgrade = __esm({
+  "src/commands/upgrade.ts"() {
+    "use strict";
+    BILLING_URL = "https://app.quikcommit.dev/billing";
+  }
+});
+
+// src/local.ts
+var local_exports = {};
+__export(local_exports, {
+  getLocalProviderConfig: () => getLocalProviderConfig,
+  runLocalCommit: () => runLocalCommit
+});
+function getLegacyProvider() {
+  try {
+    const p = (0, import_path7.join)(CONFIG_PATH2, "provider");
+    if ((0, import_fs7.existsSync)(p)) {
+      const v = (0, import_fs7.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_path7.join)(CONFIG_PATH2, "base_url");
+    if ((0, import_fs7.existsSync)(p)) {
+      return (0, import_fs7.readFileSync)(p, "utf-8").trim();
+    }
+  } catch {
+  }
+  return PROVIDER_URLS[provider] ?? "";
+}
+function getLegacyModel(provider) {
+  try {
+    const p = (0, import_path7.join)(CONFIG_PATH2, "model");
+    if ((0, import_fs7.existsSync)(p)) {
+      const v = (0, import_fs7.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) {
+  let prompt = `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) {
+    prompt += `Rules: ${JSON.stringify(rules)}
+
+`;
+  }
+  prompt += `Important:
+- Follow conventional commit format: <type>(<scope>): <subject>
+- Response should be the commit message only, no explanations`;
+  return prompt;
+}
+function buildRequest(provider, baseUrl, userContent, diff, changes, model, apiKey, rules) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  if (provider === "openrouter") {
+    headers["HTTP-Referer"] = "https://github.com/quikcommit/quikcommit";
+    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`;
+      body = { diff, changes, rules };
+      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(messageOnly, push, modelFlag) {
+  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 ?? [];
+  const diff = getStagedDiff(excludes);
+  const changes = getStagedFiles();
+  const model = modelFlag ?? local.model;
+  let rules = 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 };
+    }
+  }
+  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 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.");
+  }
+  if (messageOnly) {
+    console.log(message);
+    return;
+  }
+  gitCommit(message);
+  if (push) {
+    gitPush();
+  }
+}
+var import_fs7, import_path7, import_os4, CONFIG_PATH2, PROVIDER_URLS, DEFAULT_MODELS;
+var init_local = __esm({
+  "src/local.ts"() {
+    "use strict";
+    import_fs7 = require("fs");
+    import_path7 = require("path");
+    import_os4 = require("os");
+    init_config();
+    init_dist();
+    init_git();
+    init_monorepo();
+    CONFIG_PATH2 = (0, import_path7.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/index.ts
+init_config();
+init_api();
+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 init               Install prepare-commit-msg hook for auto-generation
+  qc login              Sign in via browser
+  qc logout             Clear local credentials
+  qc status             Show auth, plan, usage
+  qc team               Team management (info, rules, invite)
+
+Options:
+  -h, --help            Show this help
+  -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 (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
+`;
+function parseArgs(args) {
+  let command = "commit";
+  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;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      command = "help";
+    } else if (arg === "-m" || arg === "--message-only") {
+      messageOnly = true;
+    } else if (arg === "-p" || arg === "--push") {
+      push = true;
+    } else if (arg === "--api-key" && i + 1 < args.length) {
+      apiKey = args[++i];
+    } else if (arg === "--base" && i + 1 < args.length) {
+      base = args[++i];
+    } else if (arg === "--create") {
+      create = true;
+    } else if (arg === "--from" && i + 1 < args.length) {
+      from = args[++i];
+    } else if (arg === "--to" && i + 1 < args.length) {
+      to = args[++i];
+    } else if (arg === "--write") {
+      write = true;
+    } else if (arg === "--version" && i + 1 < args.length) {
+      version = args[++i];
+    } else if (arg === "--uninstall") {
+      uninstall = true;
+    } else if (arg === "--hook-mode") {
+      hookMode = true;
+    } else if (arg === "login") {
+      command = "login";
+    } else if (arg === "logout") {
+      command = "logout";
+    } else if (arg === "status") {
+      command = "status";
+    } else if (arg === "pr") {
+      command = "pr";
+    } else if (arg === "changelog") {
+      command = "changelog";
+    } else if (arg === "init") {
+      command = "init";
+    } else if (arg === "team") {
+      command = "team";
+    } else if (arg === "config") {
+      command = "config";
+    } else if (arg === "upgrade") {
+      command = "upgrade";
+    } 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, messageOnly, push, apiKey, base, create, from, to, write, version, uninstall, hookMode, model, local };
+}
+async function runCommit(messageOnly, push, apiKeyFlag, hookMode = false, modelFlag) {
+  const log = hookMode ? () => {
+  } : (msg) => console.error(msg);
+  if (!isGitRepo()) {
+    log("Error: Not a git repository.");
+    process.exit(1);
+  }
+  if (!hasStagedChanges()) {
+    log("Error: No staged changes. Stage files with `git add` first.");
+    process.exit(1);
+  }
+  const apiKey = apiKeyFlag ?? getApiKey();
+  if (!apiKey) {
+    log("Error: Not authenticated. Run `qc login` first.");
+    process.exit(1);
+  }
+  const config2 = getConfig();
+  const model = modelFlag ?? config2.model;
+  const excludes = config2.excludes ?? [];
+  const diff = getStagedDiff(excludes);
+  const changes = getStagedFiles();
+  let rules = 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 };
+    }
+  }
+  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 {
+  }
+  const { message } = await client.generateCommit(diff, changes, rules, model);
+  if (messageOnly) {
+    console.log(message);
+    return;
+  }
+  gitCommit(message);
+  if (push) {
+    gitPush();
+  }
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const values = parseArgs(argv);
+  const { command, messageOnly, push, apiKey } = values;
+  if (command === "help") {
+    console.log(HELP);
+    return;
+  }
+  if (command === "login") {
+    const { runLogin: runLogin2 } = await Promise.resolve().then(() => (init_login(), login_exports));
+    await runLogin2();
+    return;
+  }
+  if (command === "logout") {
+    const { runLogout: runLogout2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
+    runLogout2();
+    return;
+  }
+  if (command === "status") {
+    const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+    await runStatus2(apiKey);
+    return;
+  }
+  if (command === "pr") {
+    const { pr: pr2 } = await Promise.resolve().then(() => (init_pr(), pr_exports));
+    await pr2({
+      base: values.base,
+      create: values.create,
+      model: values.model ?? getConfig().model
+    });
+    return;
+  }
+  if (command === "changelog") {
+    const { changelog: changelog2 } = await Promise.resolve().then(() => (init_changelog(), changelog_exports));
+    await changelog2({
+      from: values.from,
+      to: values.to,
+      write: values.write,
+      version: values.version,
+      model: values.model ?? getConfig().model
+    });
+    return;
+  }
+  if (command === "init") {
+    const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    await init2({ uninstall: values.uninstall });
+    return;
+  }
+  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));
+    return;
+  }
+  if (command === "config") {
+    const { config: config2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+    const positionals = argv.filter((a) => !a.startsWith("-") && a !== "config");
+    await config2(positionals);
+    return;
+  }
+  if (command === "upgrade") {
+    const { upgrade: upgrade2 } = await Promise.resolve().then(() => (init_upgrade(), upgrade_exports));
+    await upgrade2();
+    return;
+  }
+  if (values.local) {
+    const { runLocalCommit: runLocalCommit2 } = await Promise.resolve().then(() => (init_local(), local_exports));
+    await runLocalCommit2(messageOnly, push, values.model);
+    return;
+  }
+  const apiKeyToUse = apiKey ?? getApiKey();
+  if (!apiKeyToUse) {
+    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);
+      return;
+    }
+  }
+  await runCommit(messageOnly, push, apiKey, values.hookMode, values.model);
+}
+main().catch((err) => {
+  const args = process.argv.slice(2);
+  const hookMode = args.includes("--hook-mode");
+  if (!hookMode) {
+    console.error(err instanceof Error ? err.message : String(err));
+  }
+  process.exit(1);
+});