contribute-now 0.1.0-staging.7136fcc

package/dist/index.js

@@ -0,0 +1,1454 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand as defineCommand9, runMain } from "citty";
+
+// src/commands/clean.ts
+import { defineCommand } from "citty";
+import pc3 from "picocolors";
+
+// src/utils/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var CONFIG_FILENAME = ".contributerc.json";
+function getConfigPath(cwd = process.cwd()) {
+  return join(cwd, CONFIG_FILENAME);
+}
+function readConfig(cwd = process.cwd()) {
+  const path = getConfigPath(cwd);
+  if (!existsSync(path))
+    return null;
+  try {
+    const raw = readFileSync(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config, cwd = process.cwd()) {
+  const path = getConfigPath(cwd);
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+}
+function isGitignored(cwd = process.cwd()) {
+  const gitignorePath = join(cwd, ".gitignore");
+  if (!existsSync(gitignorePath))
+    return false;
+  try {
+    const content = readFileSync(gitignorePath, "utf-8");
+    return content.split(`
+`).some((line) => line.trim() === CONFIG_FILENAME);
+  } catch {
+    return false;
+  }
+}
+function getDefaultConfig() {
+  return {
+    role: "contributor",
+    mainBranch: "main",
+    devBranch: "dev",
+    upstream: "upstream",
+    origin: "origin",
+    branchPrefixes: ["feature", "fix", "docs", "chore", "test", "refactor"]
+  };
+}
+
+// src/utils/confirm.ts
+import pc from "picocolors";
+async function confirmPrompt(message) {
+  console.log(`
+${message}`);
+  process.stdout.write(`${pc.dim("Continue? [y/N] ")}`);
+  const response = await new Promise((resolve) => {
+    process.stdin.setEncoding("utf-8");
+    process.stdin.once("data", (data) => {
+      process.stdin.pause();
+      resolve(data.toString().trim());
+    });
+    process.stdin.resume();
+  });
+  if (response.toLowerCase() !== "y") {
+    console.log(pc.yellow("Aborted."));
+    return false;
+  }
+  return true;
+}
+async function selectPrompt(message, choices) {
+  console.log(`
+${message}`);
+  choices.forEach((choice, i) => {
+    console.log(`  ${pc.dim(`${i + 1}.`)} ${choice}`);
+  });
+  process.stdout.write(pc.dim(`Enter number [1-${choices.length}]: `));
+  const response = await new Promise((resolve) => {
+    process.stdin.setEncoding("utf-8");
+    process.stdin.once("data", (data) => {
+      process.stdin.pause();
+      resolve(data.toString().trim());
+    });
+    process.stdin.resume();
+  });
+  const index = Number.parseInt(response, 10) - 1;
+  if (index >= 0 && index < choices.length) {
+    return choices[index];
+  }
+  return choices[0];
+}
+async function inputPrompt(message, defaultValue) {
+  const hint = defaultValue ? ` ${pc.dim(`[${defaultValue}]`)}` : "";
+  process.stdout.write(`
+${message}${hint}: `);
+  const response = await new Promise((resolve) => {
+    process.stdin.setEncoding("utf-8");
+    process.stdin.once("data", (data) => {
+      process.stdin.pause();
+      resolve(data.toString().trim());
+    });
+    process.stdin.resume();
+  });
+  return response || defaultValue || "";
+}
+
+// src/utils/git.ts
+import { execFile as execFileCb } from "node:child_process";
+function run(args) {
+  return new Promise((resolve) => {
+    execFileCb("git", args, (error, stdout, stderr) => {
+      resolve({
+        exitCode: error ? error.code === "ENOENT" ? 127 : error.code != null ? Number(error.code) : 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+async function isGitRepo() {
+  const { exitCode } = await run(["rev-parse", "--is-inside-work-tree"]);
+  return exitCode === 0;
+}
+async function getCurrentBranch() {
+  const { exitCode, stdout } = await run(["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function getRemotes() {
+  const { exitCode, stdout } = await run(["remote"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).map((r) => r.trim()).filter(Boolean);
+}
+async function getRemoteUrl(remote) {
+  const { exitCode, stdout } = await run(["remote", "get-url", remote]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.trim() || null;
+}
+async function hasUncommittedChanges() {
+  const { exitCode, stdout } = await run(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return false;
+  return stdout.trim().length > 0;
+}
+async function fetchRemote(remote) {
+  return run(["fetch", remote]);
+}
+async function fetchAll() {
+  return run(["fetch", "--all", "--quiet"]);
+}
+async function checkoutBranch(branch) {
+  return run(["checkout", branch]);
+}
+async function createBranch(branch, from) {
+  const args = from ? ["checkout", "-b", branch, from] : ["checkout", "-b", branch];
+  return run(args);
+}
+async function resetHard(ref) {
+  return run(["reset", "--hard", ref]);
+}
+async function pushForceWithLease(remote, branch) {
+  return run(["push", "--force-with-lease", remote, branch]);
+}
+async function pushSetUpstream(remote, branch) {
+  return run(["push", "-u", remote, branch]);
+}
+async function rebase(branch) {
+  return run(["rebase", branch]);
+}
+async function getStagedDiff() {
+  const { stdout } = await run(["diff", "--cached"]);
+  return stdout;
+}
+async function getStagedFiles() {
+  const { exitCode, stdout } = await run(["diff", "--cached", "--name-only"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean);
+}
+async function getChangedFiles() {
+  const { exitCode, stdout } = await run(["status", "--porcelain"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean).map((l) => l.slice(3));
+}
+async function getDivergence(branch, base) {
+  const { exitCode, stdout } = await run([
+    "rev-list",
+    "--left-right",
+    "--count",
+    `${base}...${branch}`
+  ]);
+  if (exitCode !== 0)
+    return { ahead: 0, behind: 0 };
+  const parts = stdout.trim().split(/\s+/);
+  return {
+    behind: Number.parseInt(parts[0] ?? "0", 10),
+    ahead: Number.parseInt(parts[1] ?? "0", 10)
+  };
+}
+async function getMergedBranches(base) {
+  const { exitCode, stdout } = await run(["branch", "--merged", base]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).map((b) => b.replace(/^\*?\s+/, "").trim()).filter(Boolean);
+}
+async function deleteBranch(branch) {
+  return run(["branch", "-d", branch]);
+}
+async function pruneRemote(remote) {
+  return run(["remote", "prune", remote]);
+}
+async function commitWithMessage(message) {
+  return run(["commit", "-m", message]);
+}
+async function getLogDiff(base, head) {
+  const { stdout } = await run(["diff", `${base}...${head}`]);
+  return stdout;
+}
+async function getLog(base, head) {
+  const { exitCode, stdout } = await run(["log", `${base}..${head}`, "--oneline"]);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trim().split(`
+`).filter(Boolean);
+}
+
+// src/utils/logger.ts
+import { LogEngine, LogMode } from "@wgtechlabs/log-engine";
+import pc2 from "picocolors";
+LogEngine.configure({
+  mode: LogMode.INFO,
+  format: {
+    includeIsoTimestamp: false,
+    includeLocalTime: true,
+    includeEmoji: true
+  }
+});
+function success(msg) {
+  LogEngine.log(msg);
+}
+function error(msg) {
+  LogEngine.error(msg);
+}
+function warn(msg) {
+  LogEngine.warn(msg);
+}
+function info(msg) {
+  LogEngine.info(msg);
+}
+function heading(msg) {
+  console.log(`
+${pc2.bold(msg)}`);
+}
+
+// src/commands/clean.ts
+var clean_default = defineCommand({
+  meta: {
+    name: "clean",
+    description: "Delete merged branches and prune remote refs"
+  },
+  args: {
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip confirmation prompt",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    const { mainBranch, devBranch, origin } = config;
+    const currentBranch = await getCurrentBranch();
+    heading("\uD83E\uDDF9 contrib clean");
+    const mergedBranches = await getMergedBranches(devBranch);
+    const protected_ = new Set([mainBranch, devBranch, currentBranch ?? ""]);
+    const candidates = mergedBranches.filter((b) => !protected_.has(b));
+    if (candidates.length === 0) {
+      info("No merged branches to clean up.");
+    } else {
+      console.log(`
+${pc3.bold("Branches to delete:")}`);
+      for (const b of candidates) {
+        console.log(`  ${pc3.dim("•")} ${b}`);
+      }
+      console.log();
+      const ok = args.yes || await confirmPrompt(`Delete ${pc3.bold(String(candidates.length))} merged branch${candidates.length !== 1 ? "es" : ""}?`);
+      if (!ok) {
+        info("Skipped branch deletion.");
+      } else {
+        for (const branch of candidates) {
+          const result = await deleteBranch(branch);
+          if (result.exitCode === 0) {
+            success(`  Deleted ${pc3.bold(branch)}`);
+          } else {
+            warn(`  Failed to delete ${branch}: ${result.stderr.trim()}`);
+          }
+        }
+      }
+    }
+    info(`Pruning ${origin} remote refs...`);
+    const pruneResult = await pruneRemote(origin);
+    if (pruneResult.exitCode === 0) {
+      success(`✅ Pruned ${origin} remote refs.`);
+    } else {
+      warn(`Could not prune remote: ${pruneResult.stderr.trim()}`);
+    }
+  }
+});
+
+// src/commands/commit.ts
+import { defineCommand as defineCommand2 } from "citty";
+import pc4 from "picocolors";
+
+// src/utils/copilot.ts
+import { CopilotClient } from "@github/copilot-sdk";
+var CLEAN_COMMIT_SYSTEM_PROMPT = `You are a git commit message generator. Generate a Clean Commit message following this exact format:
+<emoji> <type>[!][(<scope>)]: <description>
+
+Emoji and type table:
+\uD83D\uDCE6 new      – new features, files, or capabilities
+\uD83D\uDD27 update   – changes, refactoring, improvements
+\uD83D\uDDD1️ remove   – removing code, files, or dependencies
+\uD83D\uDD12 security – security fixes or patches
+⚙️ setup    – configs, CI/CD, tooling, build systems
+☕ chore    – maintenance, dependency updates
+\uD83E\uDDEA test     – adding or updating tests
+\uD83D\uDCD6 docs     – documentation changes
+\uD83D\uDE80 release  – version releases
+
+Rules:
+- Breaking change (!) only for: new, update, remove, security
+- Description: concise, imperative mood, max 72 chars
+- Scope: optional, camelCase or kebab-case component name
+- Return ONLY the commit message line, nothing else
+
+Examples:
+\uD83D\uDCE6 new: user authentication system
+\uD83D\uDD27 update (api): improve error handling
+⚙️ setup (ci): configure github actions workflow
+\uD83D\uDCE6 new!: completely redesign authentication system`;
+var BRANCH_NAME_SYSTEM_PROMPT = `You are a git branch name generator. Convert natural language descriptions into proper git branch names.
+
+Format: <prefix>/<kebab-case-name>
+Prefixes: feature, fix, docs, chore, test, refactor
+
+Rules:
+- Use lowercase kebab-case for the name part
+- Keep it short and descriptive (2-5 words max)
+- Return ONLY the branch name, nothing else
+
+Examples:
+Input: "fix the login timeout bug" → fix/login-timeout
+Input: "add user profile page" → feature/user-profile-page
+Input: "update readme documentation" → docs/update-readme`;
+var PR_DESCRIPTION_SYSTEM_PROMPT = `You are a GitHub pull request description generator. Create a clear, structured PR description.
+
+Return a JSON object with this exact structure:
+{
+  "title": "Brief PR title (50 chars max)",
+  "body": "## Summary\\n...\\n\\n## Changes\\n...\\n\\n## Test Plan\\n..."
+}
+
+Rules:
+- title: concise, present tense, describes what the PR does
+- body: markdown with Summary, Changes (bullet list), and Test Plan sections
+- Return ONLY the JSON object, no markdown fences, no extra text`;
+var CONFLICT_RESOLUTION_SYSTEM_PROMPT = `You are a git merge conflict resolution advisor. Analyze the conflict markers and provide guidance.
+
+Rules:
+- Explain what each side of the conflict contains
+- Suggest the most likely correct resolution strategy
+- Never auto-resolve — provide guidance only
+- Be concise and actionable`;
+async function checkCopilotAvailable() {
+  let client = null;
+  try {
+    client = new CopilotClient;
+    await client.start();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("ENOENT") || msg.includes("not found")) {
+      return "Copilot CLI binary not found. Ensure GitHub Copilot is installed and your gh CLI is up to date.";
+    }
+    return `Failed to start Copilot service: ${msg}`;
+  }
+  try {
+    await client.ping();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("auth") || msg.includes("token") || msg.includes("401") || msg.includes("403")) {
+      return "Copilot authentication failed. Run `gh auth login` to refresh your token.";
+    }
+    if (msg.includes("ECONNREFUSED") || msg.includes("timeout") || msg.includes("network")) {
+      return "Could not reach GitHub Copilot service. Check your internet connection.";
+    }
+    return `Copilot health check failed: ${msg}`;
+  } finally {
+    try {
+      await client.stop();
+    } catch {}
+  }
+  return null;
+}
+async function callCopilot(systemMessage, userMessage, model) {
+  const client = new CopilotClient;
+  await client.start();
+  try {
+    const sessionConfig = {
+      systemMessage: { content: systemMessage }
+    };
+    if (model)
+      sessionConfig.model = model;
+    const session = await client.createSession(sessionConfig);
+    try {
+      const response = await session.sendAndWait({ content: userMessage });
+      if (!response?.data?.content)
+        return null;
+      return response.data.content;
+    } finally {
+      await session.destroy();
+    }
+  } finally {
+    await client.stop();
+  }
+}
+async function generateCommitMessage(diff, stagedFiles, model) {
+  try {
+    const userMessage = `Generate a commit message for these staged changes:
+
+Files: ${stagedFiles.join(", ")}
+
+Diff:
+${diff.slice(0, 4000)}`;
+    const result = await callCopilot(CLEAN_COMMIT_SYSTEM_PROMPT, userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+async function generatePRDescription(commits, diff, model) {
+  try {
+    const userMessage = `Generate a PR description for these changes:
+
+Commits:
+${commits.join(`
+`)}
+
+Diff (truncated):
+${diff.slice(0, 4000)}`;
+    const result = await callCopilot(PR_DESCRIPTION_SYSTEM_PROMPT, userMessage, model);
+    if (!result)
+      return null;
+    const cleaned = result.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+    return JSON.parse(cleaned);
+  } catch {
+    return null;
+  }
+}
+async function suggestBranchName(description, model) {
+  try {
+    const result = await callCopilot(BRANCH_NAME_SYSTEM_PROMPT, description, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+async function suggestConflictResolution(conflictDiff, model) {
+  try {
+    const userMessage = `Help me resolve this merge conflict:
+
+${conflictDiff.slice(0, 4000)}`;
+    const result = await callCopilot(CONFLICT_RESOLUTION_SYSTEM_PROMPT, userMessage, model);
+    return result?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/commit.ts
+var CLEAN_COMMIT_PATTERN = /^(📦|🔧|🗑\uFE0F?|🔒|⚙\uFE0F?|☕|🧪|📖|🚀) (new|update|remove|security|setup|chore|test|docs|release)(!?)( \([a-zA-Z0-9][a-zA-Z0-9-]*\))?: .{1,72}$/u;
+function validateCleanCommit(msg) {
+  return CLEAN_COMMIT_PATTERN.test(msg);
+}
+var commit_default = defineCommand2({
+  meta: {
+    name: "commit",
+    description: "Stage changes and create a Clean Commit message (AI-powered)"
+  },
+  args: {
+    model: {
+      type: "string",
+      description: "AI model to use for commit message generation"
+    },
+    "no-ai": {
+      type: "boolean",
+      description: "Skip AI and write commit message manually",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    heading("\uD83D\uDCBE contrib commit");
+    const stagedFiles = await getStagedFiles();
+    if (stagedFiles.length === 0) {
+      const changedFiles = await getChangedFiles();
+      if (changedFiles.length === 0) {
+        error("No changes to commit.");
+        process.exit(1);
+      }
+      console.log(`
+${pc4.bold("Changed files:")}`);
+      for (const f of changedFiles) {
+        console.log(`  ${pc4.dim("•")} ${f}`);
+      }
+      console.log();
+      warn("No staged changes. Stage your files with `git add` and re-run.");
+      process.exit(1);
+    }
+    info(`Staged files: ${stagedFiles.join(", ")}`);
+    let commitMessage = null;
+    const useAI = !args["no-ai"];
+    if (useAI) {
+      const copilotError = await checkCopilotAvailable();
+      if (copilotError) {
+        warn(`AI unavailable: ${copilotError}`);
+        warn("Falling back to manual commit message entry.");
+      } else {
+        info("Generating commit message with AI...");
+        const diff = await getStagedDiff();
+        commitMessage = await generateCommitMessage(diff, stagedFiles, args.model);
+        if (commitMessage) {
+          console.log(`
+  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(commitMessage))}`);
+        } else {
+          warn("AI did not return a commit message. Falling back to manual entry.");
+        }
+      }
+    }
+    let finalMessage = null;
+    if (commitMessage) {
+      const action = await selectPrompt("What would you like to do?", [
+        "Accept this message",
+        "Edit this message",
+        "Regenerate",
+        "Write manually"
+      ]);
+      if (action === "Accept this message") {
+        finalMessage = commitMessage;
+      } else if (action === "Edit this message") {
+        finalMessage = await inputPrompt("Edit commit message", commitMessage);
+      } else if (action === "Regenerate") {
+        info("Regenerating...");
+        const diff = await getStagedDiff();
+        const regen = await generateCommitMessage(diff, stagedFiles, args.model);
+        if (regen) {
+          console.log(`
+  ${pc4.dim("AI suggestion:")} ${pc4.bold(pc4.cyan(regen))}`);
+          const ok = await confirmPrompt("Use this message?");
+          finalMessage = ok ? regen : await inputPrompt("Enter commit message manually");
+        } else {
+          warn("Regeneration failed. Falling back to manual entry.");
+          finalMessage = await inputPrompt("Enter commit message");
+        }
+      } else {
+        finalMessage = await inputPrompt("Enter commit message");
+      }
+    } else {
+      console.log();
+      console.log(pc4.dim("Clean Commit format: <emoji> <type>[!][(<scope>)]: <description>"));
+      console.log(pc4.dim("Examples: \uD83D\uDCE6 new: user auth | \uD83D\uDD27 update (api): improve errors"));
+      console.log();
+      finalMessage = await inputPrompt("Enter commit message");
+    }
+    if (!finalMessage) {
+      error("No commit message provided.");
+      process.exit(1);
+    }
+    if (!validateCleanCommit(finalMessage)) {
+      warn("Commit message does not follow Clean Commit format.");
+      warn("Format: <emoji> <type>[!][(<scope>)]: <description>");
+      const proceed = await confirmPrompt("Commit anyway?");
+      if (!proceed)
+        process.exit(1);
+    }
+    const result = await commitWithMessage(finalMessage);
+    if (result.exitCode !== 0) {
+      error(`Failed to commit: ${result.stderr}`);
+      process.exit(1);
+    }
+    success(`✅ Committed: ${pc4.bold(finalMessage)}`);
+  }
+});
+
+// src/commands/setup.ts
+import { defineCommand as defineCommand3 } from "citty";
+import pc5 from "picocolors";
+
+// src/utils/gh.ts
+import { execFile as execFileCb2 } from "node:child_process";
+function run2(args) {
+  return new Promise((resolve) => {
+    execFileCb2("gh", args, (error2, stdout, stderr) => {
+      resolve({
+        exitCode: error2 ? error2.code != null ? Number(error2.code) : 1 : 0,
+        stdout: stdout ?? "",
+        stderr: stderr ?? ""
+      });
+    });
+  });
+}
+async function checkGhInstalled() {
+  try {
+    const { exitCode } = await run2(["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function checkGhAuth() {
+  try {
+    const { exitCode } = await run2(["auth", "status"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function checkRepoPermissions(owner, repo) {
+  const { exitCode, stdout } = await run2(["api", `repos/${owner}/${repo}`, "--jq", ".permissions"]);
+  if (exitCode !== 0)
+    return null;
+  try {
+    return JSON.parse(stdout.trim());
+  } catch {
+    return null;
+  }
+}
+async function isRepoFork() {
+  const { exitCode, stdout } = await run2(["repo", "view", "--json", "isFork", "-q", ".isFork"]);
+  if (exitCode !== 0)
+    return null;
+  const val = stdout.trim();
+  if (val === "true")
+    return true;
+  if (val === "false")
+    return false;
+  return null;
+}
+async function getCurrentRepoInfo() {
+  const { exitCode, stdout } = await run2([
+    "repo",
+    "view",
+    "--json",
+    "nameWithOwner",
+    "-q",
+    ".nameWithOwner"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  const nameWithOwner = stdout.trim();
+  if (!nameWithOwner)
+    return null;
+  const [owner, repo] = nameWithOwner.split("/");
+  if (!owner || !repo)
+    return null;
+  return { owner, repo };
+}
+async function createPR(options) {
+  const args = [
+    "pr",
+    "create",
+    "--base",
+    options.base,
+    "--title",
+    options.title,
+    "--body",
+    options.body
+  ];
+  if (options.draft)
+    args.push("--draft");
+  return run2(args);
+}
+async function createPRFill(base, draft) {
+  const args = ["pr", "create", "--base", base, "--fill"];
+  if (draft)
+    args.push("--draft");
+  return run2(args);
+}
+
+// src/utils/remote.ts
+function parseRepoFromUrl(url) {
+  const httpsMatch = url.match(/https?:\/\/github\.com\/([^/]+)\/([^/.]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/([^/.]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  return null;
+}
+async function getRepoInfoFromRemote(remote = "origin") {
+  const url = await getRemoteUrl(remote);
+  if (!url)
+    return null;
+  return parseRepoFromUrl(url);
+}
+
+// src/commands/setup.ts
+var setup_default = defineCommand3({
+  meta: {
+    name: "setup",
+    description: "Initialize contribute-now config for this repo (.contributerc.json)"
+  },
+  async run() {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository. Run this command from within a git repo.");
+      process.exit(1);
+    }
+    heading("\uD83D\uDD27 contribute-now setup");
+    const remotes = await getRemotes();
+    if (remotes.length === 0) {
+      error("No git remotes found. Add a remote first (e.g., git remote add origin <url>).");
+      process.exit(1);
+    }
+    info(`Found remotes: ${remotes.join(", ")}`);
+    let detectedRole = null;
+    let detectionSource = "";
+    const ghInstalled = await checkGhInstalled();
+    if (ghInstalled && await checkGhAuth()) {
+      const isFork = await isRepoFork();
+      if (isFork === true) {
+        detectedRole = "contributor";
+        detectionSource = "gh CLI (fork detected)";
+      } else if (isFork === false) {
+        const repoInfo = await getCurrentRepoInfo();
+        if (repoInfo) {
+          const perms = await checkRepoPermissions(repoInfo.owner, repoInfo.repo);
+          if (perms?.admin || perms?.push) {
+            detectedRole = "maintainer";
+            detectionSource = "gh CLI (admin/push permissions)";
+          }
+        }
+      }
+    }
+    if (detectedRole === null) {
+      if (remotes.includes("upstream")) {
+        detectedRole = "contributor";
+        detectionSource = "heuristic (upstream remote exists)";
+      } else if (remotes.includes("origin") && remotes.length === 1) {
+        detectedRole = "maintainer";
+        detectionSource = "heuristic (only origin remote)";
+      }
+    }
+    if (detectedRole === null) {
+      const roleChoice = await selectPrompt("What is your role in this project?", [
+        "maintainer",
+        "contributor"
+      ]);
+      detectedRole = roleChoice;
+      detectionSource = "user selection";
+    } else {
+      info(`Detected role: ${pc5.bold(detectedRole)} (via ${detectionSource})`);
+      const confirmed = await confirmPrompt(`Role detected as ${pc5.bold(detectedRole)}. Is this correct?`);
+      if (!confirmed) {
+        const roleChoice = await selectPrompt("Select your role:", ["maintainer", "contributor"]);
+        detectedRole = roleChoice;
+      }
+    }
+    const defaultConfig = getDefaultConfig();
+    const mainBranch = await inputPrompt("Main branch name", defaultConfig.mainBranch);
+    const devBranch = await inputPrompt("Dev branch name", defaultConfig.devBranch);
+    const originRemote = await inputPrompt("Origin remote name", defaultConfig.origin);
+    let upstreamRemote = defaultConfig.upstream;
+    if (detectedRole === "contributor") {
+      upstreamRemote = await inputPrompt("Upstream remote name", defaultConfig.upstream);
+      if (!remotes.includes(upstreamRemote)) {
+        warn(`Remote "${upstreamRemote}" not found.`);
+        const originUrl = await getRemoteUrl(originRemote);
+        const repoInfo = originUrl ? parseRepoFromUrl(originUrl) : null;
+        const upstreamUrl = await inputPrompt("Enter upstream repository URL to add", repoInfo ? `https://github.com/${repoInfo.owner}/${repoInfo.repo}` : undefined);
+        if (upstreamUrl) {
+          info(`Run: git remote add ${upstreamRemote} ${upstreamUrl}`);
+          warn("Please add the upstream remote and re-run setup, or add it manually.");
+        }
+      }
+    }
+    const config = {
+      role: detectedRole,
+      mainBranch,
+      devBranch,
+      upstream: upstreamRemote,
+      origin: originRemote,
+      branchPrefixes: defaultConfig.branchPrefixes
+    };
+    writeConfig(config);
+    success(`✅ Config written to .contributerc.json`);
+    if (!isGitignored()) {
+      warn(".contributerc.json is not in .gitignore. Add it to avoid committing personal config.");
+      warn('  echo ".contributerc.json" >> .gitignore');
+    }
+    console.log();
+    info(`Role: ${pc5.bold(config.role)}`);
+    info(`Main: ${pc5.bold(config.mainBranch)} | Dev: ${pc5.bold(config.devBranch)}`);
+    info(`Origin: ${pc5.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc5.bold(config.upstream)}` : ""}`);
+  }
+});
+
+// src/commands/start.ts
+import { defineCommand as defineCommand4 } from "citty";
+import pc6 from "picocolors";
+
+// src/utils/branch.ts
+var DEFAULT_PREFIXES = ["feature", "fix", "docs", "chore", "test", "refactor"];
+function hasPrefix(branchName, prefixes = DEFAULT_PREFIXES) {
+  return prefixes.some((p) => branchName.startsWith(`${p}/`));
+}
+function formatBranchName(prefix, name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${prefix}/${sanitized}`;
+}
+function looksLikeNaturalLanguage(input) {
+  return input.includes(" ") && !input.includes("/");
+}
+
+// src/commands/start.ts
+var start_default = defineCommand4({
+  meta: {
+    name: "start",
+    description: "Create a new feature branch from the latest dev"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Branch name or description",
+      required: true
+    },
+    model: {
+      type: "string",
+      description: "AI model to use for branch name suggestion"
+    },
+    "no-ai": {
+      type: "boolean",
+      description: "Skip AI branch name suggestion",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    if (await hasUncommittedChanges()) {
+      error("You have uncommitted changes. Please commit or stash them before creating a branch.");
+      process.exit(1);
+    }
+    const { devBranch, origin, upstream, branchPrefixes, role } = config;
+    let branchName = args.name;
+    heading("\uD83C\uDF3F contrib start");
+    const useAI = !args["no-ai"] && looksLikeNaturalLanguage(branchName);
+    if (useAI) {
+      info("Generating branch name suggestion from description...");
+      const suggested = await suggestBranchName(branchName, args.model);
+      if (suggested) {
+        console.log(`
+  ${pc6.dim("AI suggestion:")} ${pc6.bold(pc6.cyan(suggested))}`);
+        const accepted = await confirmPrompt(`Use ${pc6.bold(suggested)} as your branch name?`);
+        if (accepted) {
+          branchName = suggested;
+        } else {
+          branchName = await inputPrompt("Enter branch name", branchName);
+        }
+      }
+    }
+    if (!hasPrefix(branchName, branchPrefixes)) {
+      const prefix = await selectPrompt(`Choose a branch type for ${pc6.bold(branchName)}:`, branchPrefixes);
+      branchName = formatBranchName(prefix, branchName);
+    }
+    info(`Creating branch: ${pc6.bold(branchName)}`);
+    const remote = role === "contributor" ? upstream : origin;
+    const remoteDevRef = role === "contributor" ? `${upstream}/${devBranch}` : `${origin}/${devBranch}`;
+    await fetchRemote(remote);
+    const resetResult = await resetHard(remoteDevRef);
+    if (resetResult.exitCode !== 0) {}
+    const result = await createBranch(branchName, devBranch);
+    if (result.exitCode !== 0) {
+      error(`Failed to create branch: ${result.stderr}`);
+      process.exit(1);
+    }
+    success(`✅ Created ${pc6.bold(branchName)} from latest ${pc6.bold(devBranch)}`);
+  }
+});
+
+// src/commands/status.ts
+import { defineCommand as defineCommand5 } from "citty";
+import pc7 from "picocolors";
+var status_default = defineCommand5({
+  meta: {
+    name: "status",
+    description: "Show sync status of main, dev, and current branch"
+  },
+  async run() {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    heading("\uD83D\uDCCA contribute-now status");
+    await fetchAll();
+    const currentBranch = await getCurrentBranch();
+    const { mainBranch, devBranch, origin, upstream } = config;
+    const isContributor = config.role === "contributor";
+    const dirty = await hasUncommittedChanges();
+    if (dirty) {
+      console.log(`  ${pc7.yellow("⚠")}  ${pc7.yellow("Uncommitted changes in working tree")}`);
+      console.log();
+    }
+    const mainRemote = `${origin}/${mainBranch}`;
+    const mainDiv = await getDivergence(mainBranch, mainRemote);
+    const mainStatus = formatStatus(mainBranch, mainRemote, mainDiv.ahead, mainDiv.behind);
+    console.log(mainStatus);
+    const devRemoteRef = isContributor ? `${upstream}/${devBranch}` : `${origin}/${mainBranch}`;
+    const devDiv = await getDivergence(devBranch, devRemoteRef);
+    let devLine = formatStatus(devBranch, devRemoteRef, devDiv.ahead, devDiv.behind);
+    if (!isContributor && devDiv.ahead > 0 && devDiv.behind > 0) {
+      devLine += pc7.red(" (needs sync! squash-merge divergence detected)");
+    } else if (devDiv.ahead > 0 && devDiv.behind === 0) {
+      devLine += pc7.yellow(" (needs sync!)");
+    }
+    console.log(devLine);
+    if (currentBranch && currentBranch !== mainBranch && currentBranch !== devBranch) {
+      const branchDiv = await getDivergence(currentBranch, devBranch);
+      const branchLine = formatStatus(currentBranch, devBranch, branchDiv.ahead, branchDiv.behind);
+      console.log(branchLine + pc7.dim(` (current ${pc7.green("*")})`));
+    } else if (currentBranch) {
+      if (currentBranch === mainBranch) {
+        console.log(pc7.dim(`  (on ${pc7.bold(mainBranch)} branch)`));
+      } else if (currentBranch === devBranch) {
+        console.log(pc7.dim(`  (on ${pc7.bold(devBranch)} branch)`));
+      }
+    }
+    console.log();
+  }
+});
+function formatStatus(branch, base, ahead, behind) {
+  const label = pc7.bold(branch.padEnd(20));
+  if (ahead === 0 && behind === 0) {
+    return `  ${pc7.green("✓")}  ${label} ${pc7.dim(`in sync with ${base}`)}`;
+  }
+  if (ahead > 0 && behind === 0) {
+    return `  ${pc7.yellow("↑")}  ${label} ${pc7.yellow(`${ahead} commit${ahead !== 1 ? "s" : ""} ahead of ${base}`)}`;
+  }
+  if (behind > 0 && ahead === 0) {
+    return `  ${pc7.red("↓")}  ${label} ${pc7.red(`${behind} commit${behind !== 1 ? "s" : ""} behind ${base}`)}`;
+  }
+  return `  ${pc7.red("⚡")}  ${label} ${pc7.yellow(`${ahead} ahead`)}${pc7.dim(", ")}${pc7.red(`${behind} behind`)} ${pc7.dim(base)}`;
+}
+
+// src/commands/submit.ts
+import { defineCommand as defineCommand6 } from "citty";
+import pc8 from "picocolors";
+var submit_default = defineCommand6({
+  meta: {
+    name: "submit",
+    description: "Push current branch and create a pull request"
+  },
+  args: {
+    draft: {
+      type: "boolean",
+      description: "Create PR as draft",
+      default: false
+    },
+    "no-ai": {
+      type: "boolean",
+      description: "Skip AI PR description generation",
+      default: false
+    },
+    model: {
+      type: "string",
+      description: "AI model to use for PR description generation"
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    const { mainBranch, devBranch, origin } = config;
+    const currentBranch = await getCurrentBranch();
+    if (!currentBranch) {
+      error("Could not determine current branch.");
+      process.exit(1);
+    }
+    if (currentBranch === mainBranch || currentBranch === devBranch) {
+      error(`Cannot submit ${pc8.bold(mainBranch)} or ${pc8.bold(devBranch)} as a PR. Switch to your feature branch.`);
+      process.exit(1);
+    }
+    heading("\uD83D\uDE80 contrib submit");
+    info(`Pushing ${pc8.bold(currentBranch)} to ${origin}...`);
+    const pushResult = await pushSetUpstream(origin, currentBranch);
+    if (pushResult.exitCode !== 0) {
+      error(`Failed to push: ${pushResult.stderr}`);
+      process.exit(1);
+    }
+    const ghInstalled = await checkGhInstalled();
+    const ghAuthed = ghInstalled && await checkGhAuth();
+    if (!ghInstalled || !ghAuthed) {
+      const repoInfo = await getRepoInfoFromRemote(origin);
+      if (repoInfo) {
+        const prUrl = `https://github.com/${repoInfo.owner}/${repoInfo.repo}/compare/${devBranch}...${currentBranch}?expand=1`;
+        console.log();
+        info("Create your PR manually:");
+        console.log(`  ${pc8.cyan(prUrl)}`);
+      } else {
+        info("gh CLI not available. Create your PR manually on GitHub.");
+      }
+      return;
+    }
+    let prTitle = null;
+    let prBody = null;
+    if (!args["no-ai"]) {
+      const copilotError = await checkCopilotAvailable();
+      if (!copilotError) {
+        info("Generating AI PR description...");
+        const commits = await getLog(devBranch, "HEAD");
+        const diff = await getLogDiff(devBranch, "HEAD");
+        const result = await generatePRDescription(commits, diff, args.model);
+        if (result) {
+          prTitle = result.title;
+          prBody = result.body;
+          console.log(`
+  ${pc8.dim("AI title:")} ${pc8.bold(pc8.cyan(prTitle))}`);
+          console.log(`
+${pc8.dim("AI body preview:")}`);
+          console.log(pc8.dim(prBody.slice(0, 300) + (prBody.length > 300 ? "..." : "")));
+        } else {
+          warn("AI did not return a PR description.");
+        }
+      } else {
+        warn(`AI unavailable: ${copilotError}`);
+      }
+    }
+    if (prTitle && prBody) {
+      const action = await selectPrompt("What would you like to do with the PR description?", [
+        "Use AI description",
+        "Edit title",
+        "Write manually",
+        "Use gh --fill (auto-fill from commits)"
+      ]);
+      if (action === "Use AI description") {} else if (action === "Edit title") {
+        prTitle = await inputPrompt("PR title", prTitle);
+      } else if (action === "Write manually") {
+        prTitle = await inputPrompt("PR title");
+        prBody = await inputPrompt("PR body (markdown)");
+      } else {
+        const fillResult = await createPRFill(devBranch, args.draft);
+        if (fillResult.exitCode !== 0) {
+          error(`Failed to create PR: ${fillResult.stderr}`);
+          process.exit(1);
+        }
+        success(`✅ PR created: ${fillResult.stdout.trim()}`);
+        return;
+      }
+    } else {
+      const useManual = await confirmPrompt("Create PR with manual title/body?");
+      if (useManual) {
+        prTitle = await inputPrompt("PR title");
+        prBody = await inputPrompt("PR body (markdown)");
+      } else {
+        const fillResult = await createPRFill(devBranch, args.draft);
+        if (fillResult.exitCode !== 0) {
+          error(`Failed to create PR: ${fillResult.stderr}`);
+          process.exit(1);
+        }
+        success(`✅ PR created: ${fillResult.stdout.trim()}`);
+        return;
+      }
+    }
+    if (!prTitle) {
+      error("No PR title provided.");
+      process.exit(1);
+    }
+    const prResult = await createPR({
+      base: devBranch,
+      title: prTitle,
+      body: prBody ?? "",
+      draft: args.draft
+    });
+    if (prResult.exitCode !== 0) {
+      error(`Failed to create PR: ${prResult.stderr}`);
+      process.exit(1);
+    }
+    success(`✅ PR created: ${prResult.stdout.trim()}`);
+  }
+});
+
+// src/commands/sync.ts
+import { defineCommand as defineCommand7 } from "citty";
+import pc9 from "picocolors";
+var sync_default = defineCommand7({
+  meta: {
+    name: "sync",
+    description: "Reset dev branch to match origin/main (maintainer) or upstream/dev (contributor)"
+  },
+  args: {
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip confirmation prompt",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    const { role, mainBranch, devBranch, origin, upstream } = config;
+    if (await hasUncommittedChanges()) {
+      error("You have uncommitted changes. Please commit or stash them before syncing.");
+      process.exit(1);
+    }
+    heading(`\uD83D\uDD04 contrib sync (${role})`);
+    if (role === "maintainer") {
+      info(`Fetching ${origin}...`);
+      const fetchResult = await fetchRemote(origin);
+      if (fetchResult.exitCode !== 0) {
+        error(`Failed to fetch ${origin}: ${fetchResult.stderr}`);
+        process.exit(1);
+      }
+      const div = await getDivergence(devBranch, `${origin}/${mainBranch}`);
+      if (div.ahead > 0 || div.behind > 0) {
+        info(`${pc9.bold(devBranch)} is ${pc9.yellow(`${div.ahead} ahead`)} and ${pc9.red(`${div.behind} behind`)} ${origin}/${mainBranch}`);
+      } else {
+        info(`${pc9.bold(devBranch)} is already in sync with ${origin}/${mainBranch}`);
+      }
+      if (!args.yes) {
+        const ok = await confirmPrompt(`This will reset ${pc9.bold(devBranch)} to match ${pc9.bold(`${origin}/${mainBranch}`)}.`);
+        if (!ok)
+          process.exit(0);
+      }
+      const coResult = await checkoutBranch(devBranch);
+      if (coResult.exitCode !== 0) {
+        error(`Failed to checkout ${devBranch}: ${coResult.stderr}`);
+        process.exit(1);
+      }
+      const resetResult = await resetHard(`${origin}/${mainBranch}`);
+      if (resetResult.exitCode !== 0) {
+        error(`Failed to reset: ${resetResult.stderr}`);
+        process.exit(1);
+      }
+      const pushResult = await pushForceWithLease(origin, devBranch);
+      if (pushResult.exitCode !== 0) {
+        error(`Failed to push: ${pushResult.stderr}`);
+        process.exit(1);
+      }
+      success(`✅ ${devBranch} has been reset to match ${origin}/${mainBranch} and pushed.`);
+    } else {
+      info(`Fetching ${upstream}...`);
+      const fetchResult = await fetchRemote(upstream);
+      if (fetchResult.exitCode !== 0) {
+        error(`Failed to fetch ${upstream}: ${fetchResult.stderr}`);
+        process.exit(1);
+      }
+      if (!args.yes) {
+        const ok = await confirmPrompt(`This will reset local ${pc9.bold(devBranch)} to match ${pc9.bold(`${upstream}/${devBranch}`)}.`);
+        if (!ok)
+          process.exit(0);
+      }
+      const coResult = await checkoutBranch(devBranch);
+      if (coResult.exitCode !== 0) {
+        error(`Failed to checkout ${devBranch}: ${coResult.stderr}`);
+        process.exit(1);
+      }
+      const resetResult = await resetHard(`${upstream}/${devBranch}`);
+      if (resetResult.exitCode !== 0) {
+        error(`Failed to reset: ${resetResult.stderr}`);
+        process.exit(1);
+      }
+      const pushResult = await pushForceWithLease(origin, devBranch);
+      if (pushResult.exitCode !== 0) {
+        error(`Failed to push: ${pushResult.stderr}`);
+        process.exit(1);
+      }
+      success(`✅ ${devBranch} has been reset to match ${upstream}/${devBranch} and pushed.`);
+    }
+  }
+});
+
+// src/commands/update.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { defineCommand as defineCommand8 } from "citty";
+import pc10 from "picocolors";
+var update_default = defineCommand8({
+  meta: {
+    name: "update",
+    description: "Rebase current branch onto latest dev"
+  },
+  args: {
+    model: {
+      type: "string",
+      description: "AI model to use for conflict resolution suggestions"
+    },
+    "no-ai": {
+      type: "boolean",
+      description: "Skip AI conflict resolution suggestions",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (!await isGitRepo()) {
+      error("Not inside a git repository.");
+      process.exit(1);
+    }
+    const config = readConfig();
+    if (!config) {
+      error("No .contributerc.json found. Run `contrib setup` first.");
+      process.exit(1);
+    }
+    const { mainBranch, devBranch, origin, upstream, role } = config;
+    const currentBranch = await getCurrentBranch();
+    if (!currentBranch) {
+      error("Could not determine current branch.");
+      process.exit(1);
+    }
+    if (currentBranch === mainBranch || currentBranch === devBranch) {
+      error(`Use \`contrib sync\` to update ${pc10.bold(mainBranch)} or ${pc10.bold(devBranch)} branches.`);
+      process.exit(1);
+    }
+    if (await hasUncommittedChanges()) {
+      error("You have uncommitted changes. Please commit or stash them first.");
+      process.exit(1);
+    }
+    heading("\uD83D\uDD03 contrib update");
+    info(`Updating ${pc10.bold(currentBranch)} with latest ${pc10.bold(devBranch)}...`);
+    const remote = role === "contributor" ? upstream : origin;
+    const remoteDevRef = role === "contributor" ? `${upstream}/${devBranch}` : `${origin}/${devBranch}`;
+    await fetchRemote(remote);
+    await resetHard(remoteDevRef);
+    const rebaseResult = await rebase(devBranch);
+    if (rebaseResult.exitCode !== 0) {
+      warn("Rebase hit conflicts. Resolve them manually.");
+      console.log();
+      if (!args["no-ai"]) {
+        const copilotError = await checkCopilotAvailable();
+        if (!copilotError) {
+          info("Fetching AI conflict resolution suggestions...");
+          const conflictFiles = await getChangedFiles();
+          let conflictDiff = "";
+          for (const file of conflictFiles.slice(0, 3)) {
+            try {
+              const content = readFileSync2(file, "utf-8");
+              if (content.includes("<<<<<<<")) {
+                conflictDiff += `
+--- ${file} ---
+${content.slice(0, 2000)}
+`;
+              }
+            } catch {}
+          }
+          if (conflictDiff) {
+            const suggestion = await suggestConflictResolution(conflictDiff, args.model);
+            if (suggestion) {
+              console.log(`
+${pc10.bold("\uD83D\uDCA1 AI Conflict Resolution Guidance:")}`);
+              console.log(pc10.dim("─".repeat(60)));
+              console.log(suggestion);
+              console.log(pc10.dim("─".repeat(60)));
+              console.log();
+            }
+          }
+        }
+      }
+      console.log(pc10.bold("To resolve:"));
+      console.log(`  1. Fix conflicts in the affected files`);
+      console.log(`  2. ${pc10.cyan("git add <resolved-files>")}`);
+      console.log(`  3. ${pc10.cyan("git rebase --continue")}`);
+      console.log();
+      console.log(`  Or abort: ${pc10.cyan("git rebase --abort")}`);
+      process.exit(1);
+    }
+    success(`✅ ${pc10.bold(currentBranch)} has been rebased onto latest ${pc10.bold(devBranch)}`);
+  }
+});
+
+// src/ui/banner.ts
+import figlet from "figlet";
+import pc11 from "picocolors";
+// package.json
+var package_default = {
+  name: "contribute-now",
+  version: "0.1.0-staging.7136fcc",
+  description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
+  type: "module",
+  bin: {
+    contrib: "dist/index.js",
+    contribute: "dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bun build src/index.ts --outfile dist/index.js --target node --packages external",
+    dev: "bun src/index.ts",
+    test: "bun test",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    format: "biome format --write .",
+    prepare: "husky || true"
+  },
+  engines: {
+    node: ">=18",
+    bun: ">=1.0"
+  },
+  keywords: [
+    "git",
+    "workflow",
+    "squash-merge",
+    "sync",
+    "cli",
+    "contribute",
+    "fork",
+    "dev-branch",
+    "clean-commit"
+  ],
+  author: "Waren Gonzaga",
+  license: "GPL-3.0",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/warengonzaga/contribute-now.git"
+  },
+  dependencies: {
+    "@github/copilot-sdk": "^0.1.25",
+    "@wgtechlabs/log-engine": "^2.3.1",
+    citty: "^0.1.6",
+    figlet: "^1.10.0",
+    picocolors: "^1.1.1"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.4.4",
+    "@types/bun": "latest",
+    "@types/figlet": "^1.7.0",
+    husky: "^9.1.7",
+    typescript: "^5.7.0"
+  }
+};
+
+// src/ui/banner.ts
+var LOGO;
+try {
+  LOGO = figlet.textSync("contrib", { font: "ANSI Shadow" });
+} catch {
+  LOGO = "contribute-now";
+}
+function getVersion() {
+  return package_default.version ?? "unknown";
+}
+function getAuthor() {
+  return typeof package_default.author === "string" ? package_default.author : "unknown";
+}
+function showBanner(minimal = false) {
+  console.log(pc11.cyan(`
+${LOGO}`));
+  console.log(`  ${pc11.dim(`v${getVersion()}`)} ${pc11.dim("—")} ${pc11.dim(`Built by ${getAuthor()}`)}`);
+  if (!minimal) {
+    console.log(`  ${pc11.dim(package_default.description)}`);
+    console.log();
+    console.log(`  ${pc11.yellow("Star")}        ${pc11.cyan("https://github.com/warengonzaga/contribute-now")}`);
+    console.log(`  ${pc11.green("Contribute")}  ${pc11.cyan("https://github.com/warengonzaga/contribute-now/blob/main/CONTRIBUTING.md")}`);
+    console.log(`  ${pc11.magenta("Sponsor")}     ${pc11.cyan("https://warengonzaga.com/sponsor")}`);
+  }
+  console.log();
+}
+
+// src/index.ts
+var isHelp = process.argv.includes("--help") || process.argv.includes("-h");
+showBanner(isHelp);
+var main = defineCommand9({
+  meta: {
+    name: "contrib",
+    version: getVersion(),
+    description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges."
+  },
+  args: {
+    version: {
+      type: "boolean",
+      alias: "v",
+      description: "Show version number"
+    }
+  },
+  subCommands: {
+    setup: setup_default,
+    sync: sync_default,
+    start: start_default,
+    commit: commit_default,
+    update: update_default,
+    submit: submit_default,
+    clean: clean_default,
+    status: status_default
+  },
+  run({ args }) {
+    if (args.version) {
+      console.log(`contrib v${getVersion()}`);
+    }
+  }
+});
+runMain(main);