contribute-now 0.4.0 → 0.4.1-dev.23d6614

package/README.md

@@ -64,7 +64,7 @@ bun install -g contribute-now
 ## Prerequisites
 
 - **[Git](https://git-scm.com/)** — required
-- **[GitHub CLI](https://cli.github.com)** (`gh`) — optional; enables role auto-detection and PR creation
+- **[GitHub CLI](https://cli.github.com)** (`gh`) — recommended; required for PR creation, role detection, and merge status checks
 - **[GitHub Copilot](https://github.com/features/copilot)** — optional; enables AI features
 
 ---
@@ -129,10 +129,13 @@ Stage your changes and create a validated, AI-generated commit message matching
 contrib commit                     # AI-generated message
 contrib commit --no-ai             # manual entry, still validated
 contrib commit --model gpt-4.1    # specific AI model
+contrib commit --group             # AI groups changes into atomic commits
 ```
 
 After the AI generates a message, you can **accept**, **edit**, **regenerate**, or **write manually**. Messages are always validated against your convention — with a soft warning if they don't match (you can still commit).
 
+**Group commit mode** (`--group`): AI analyzes all staged and unstaged changes, groups related files into logical atomic commits, and generates a commit message for each group. Great for splitting a large set of changes into clean, reviewable commits.
+
 ---
 
 ### `contrib update`
@@ -180,6 +183,57 @@ contrib status
 
 ---
 
+### `contrib doctor`
+
+Diagnose the contribute-now CLI environment and configuration. Checks tools, dependencies, config, git state, fork setup, workflow, and environment.
+
+```bash
+contrib doctor          # pretty-printed report
+contrib doctor --json   # machine-readable JSON output
+```
+
+Checks include:
+- CLI version and runtime (Bun/Node)
+- git and GitHub CLI availability and authentication
+- `.contributerc.json` validity and `.gitignore` status
+- Git repo state (uncommitted changes, lock files, shallow clone)
+- Fork and remote configuration
+- Workflow and branch setup
+
+---
+
+### `contrib log`
+
+Show a colorized, workflow-aware commit log. By default it shows only **local unpushed commits** — the changes you've made since the last push (or since branching off the base branch). Use flags to switch between different views.
+
+```bash
+contrib log                # local unpushed commits (default)
+contrib log --remote       # commits on remote not yet pulled
+contrib log --full         # full history for the current branch
+contrib log --all          # commits across all branches
+contrib log -n 50          # change the commit limit (default: 20)
+contrib log -b feature/x   # log for a specific branch
+contrib log --no-graph     # flat view without graph lines
+```
+
+When no upstream tracking is set (branch hasn't been pushed yet), the command automatically compares against the base branch from your config (e.g., `origin/dev`). Protected branches are highlighted, and the current branch is color-coded for quick orientation.
+
+---
+
+### `contrib branch`
+
+List branches with workflow-aware labels and tracking status.
+
+```bash
+contrib branch             # local branches
+contrib branch --all       # local + remote branches
+contrib branch --remote    # remote branches only
+```
+
+Branches are annotated with workflow labels (e.g., base, dev, feature) and tracking info (upstream, gone, no remote).
+
+---
+
 ### `contrib hook`
 
 Install or uninstall a `commit-msg` git hook that validates every commit against your configured convention — no Husky or lint-staged needed.
@@ -210,8 +264,9 @@ contrib validate "added stuff"                   # exit 1
 All AI features are powered by **GitHub Copilot** via `@github/copilot-sdk` and are entirely **optional** — every command has a manual fallback.
 
 | Command | AI Feature | Fallback |
-|---------|------------|---------|
+|---------|------------|----------|
 | `commit` | Generate commit message from staged diff | Type manually |
+| `commit --group` | Group related changes into atomic commits | Manual staging + commit |
 | `start` | Suggest branch name from natural language | Prefix picker + manual |
 | `update` | Conflict resolution guidance | Standard git instructions |
 | `submit` | Generate PR title and body | `gh pr create --fill` or manual |
@@ -299,15 +354,40 @@ bun test        # run tests
 bun run lint    # check code quality
 ```
 
-## Contributing
+## 🎯 Contributing
 
-Contributions are welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for the workflow, commit convention, and PR guidelines.
+Contributions are welcome, create a pull request to this repo and I will review your code. Please consider to submit your pull request to the `dev` branch. Thank you!
 
-## License
+Read the project's [contributing guide](./CONTRIBUTING.md) for more info.
 
-[GPL-3.0](LICENSE) © [Waren Gonzaga](https://warengonzaga.com)
+## 🐛 Issues
 
----
+Please report any issues and bugs by [creating a new issue here](https://github.com/warengonzaga/contribute-now/issues/new/choose), also make sure you're reporting an issue that doesn't exist. Any help to improve the project would be appreciated. Thanks! 🙏✨
+
+## 🙏 Sponsor
+
+Like this project? **Leave a star**! ⭐⭐⭐⭐⭐
+
+Want to support my work and get some perks? [Become a sponsor](https://github.com/sponsors/warengonzaga)! 💖
+
+Or, you just love what I do? [Buy me a coffee](https://buymeacoffee.com/warengonzaga)! ☕
 
-💻💖☕ Made with ❤️ by [Waren Gonzaga](https://github.com/warengonzaga)
+Recognized my open-source contributions? [Nominate me](https://stars.github.com/nominate) as GitHub Star! 💫
+
+## 📋 Code of Conduct
+
+Read the project's [code of conduct](./CODE_OF_CONDUCT.md).
+
+## 📃 License
+
+This project is licensed under [GNU General Public License v3.0](https://opensource.org/licenses/GPL-3.0).
+
+## 📝 Author
+
+This project is created by **[Waren Gonzaga](https://github.com/warengonzaga)**, with the help of awesome [contributors](https://github.com/warengonzaga/contribute-now/graphs/contributors).
+
+[![contributors](https://contrib.rocks/image?repo=warengonzaga/contribute-now)](https://github.com/warengonzaga/contribute-now/graphs/contributors)
+
+---
 
+💻💖☕ by [Waren Gonzaga](https://warengonzaga.com) & [YHWH](https://www.youtube.com/watch?v=VOZbswniA-g) 🙏 — Without *Him*, none of this exists, *even me*.

package/dist/index.js

@@ -10,7 +10,7 @@ import { defineCommand } from "citty";
 import pc2 from "picocolors";
 
 // src/utils/config.ts
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 var CONFIG_FILENAME = ".contributerc.json";
 function getConfigPath(cwd = process.cwd()) {
@@ -86,6 +86,23 @@ function isGitignored(cwd = process.cwd()) {
     return false;
   }
 }
+function ensureGitignored(cwd = process.cwd()) {
+  if (isGitignored(cwd))
+    return false;
+  const gitignorePath = join(cwd, ".gitignore");
+  const line = `${CONFIG_FILENAME}
+`;
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, line, "utf-8");
+    return true;
+  }
+  const content = readFileSync(gitignorePath, "utf-8");
+  const needsLeadingNewline = content.length > 0 && !content.endsWith(`
+`);
+  appendFileSync(gitignorePath, `${needsLeadingNewline ? `
+` : ""}${line}`, "utf-8");
+  return true;
+}
 function getDefaultConfig() {
   return {
     workflow: "clean-flow",
@@ -530,6 +547,76 @@ async function getLogEntries(options) {
     return { hash: hash.trim(), subject: subject.trim(), refs: refs.trim() };
   });
 }
+async function getLocalCommitsGraph(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = [
+    "log",
+    "--oneline",
+    "--graph",
+    "--decorate",
+    `--max-count=${count}`,
+    "--color=never",
+    `${upstream}..HEAD`
+  ];
+  const { exitCode, stdout } = await run(args);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean);
+}
+async function getLocalCommitsEntries(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = ["log", `--format=%h||%s||%D`, `--max-count=${count}`, `${upstream}..HEAD`];
+  const { exitCode, stdout } = await run(args);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean).map((line) => {
+    const [hash = "", subject = "", refs = ""] = line.split("||");
+    return { hash: hash.trim(), subject: subject.trim(), refs: refs.trim() };
+  });
+}
+async function getRemoteOnlyCommitsGraph(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = [
+    "log",
+    "--oneline",
+    "--graph",
+    "--decorate",
+    `--max-count=${count}`,
+    "--color=never",
+    `HEAD..${upstream}`
+  ];
+  const { exitCode, stdout } = await run(args);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean);
+}
+async function getRemoteOnlyCommitsEntries(options) {
+  const count = options?.count ?? 20;
+  const upstream = options?.upstream;
+  if (!upstream)
+    return [];
+  const args = ["log", `--format=%h||%s||%D`, `--max-count=${count}`, `HEAD..${upstream}`];
+  const { exitCode, stdout } = await run(args);
+  if (exitCode !== 0)
+    return [];
+  return stdout.trimEnd().split(`
+`).filter(Boolean).map((line) => {
+    const [hash = "", subject = "", refs = ""] = line.split("||");
+    return { hash: hash.trim(), subject: subject.trim(), refs: refs.trim() };
+  });
+}
 async function getLocalBranches() {
   const { exitCode, stdout } = await run(["branch", "-vv", "--no-color"]);
   if (exitCode !== 0)
@@ -558,6 +645,17 @@ async function getRemoteBranches() {
   return stdout.trimEnd().split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.includes(" -> "));
 }
+async function isBranchMergedInto(branch, base) {
+  const { exitCode } = await run(["merge-base", "--is-ancestor", branch, base]);
+  return exitCode === 0;
+}
+async function getLastCommitDate(branch) {
+  const { exitCode, stdout } = await run(["log", "-1", "--format=%aI", branch]);
+  if (exitCode !== 0)
+    return null;
+  const date = stdout.trim();
+  return date || null;
+}
 
 // src/utils/logger.ts
 import { LogEngine, LogMode } from "@wgtechlabs/log-engine";
@@ -953,6 +1051,79 @@ function withTimeout(promise, ms) {
 }
 var COPILOT_TIMEOUT_MS = 30000;
 var COPILOT_LONG_TIMEOUT_MS = 90000;
+var BATCH_CONFIG = {
+  LARGE_CHANGESET_THRESHOLD: 15,
+  COMPACT_PER_FILE_CHARS: 300,
+  MAX_COMPACT_PAYLOAD: 1e4,
+  FALLBACK_BATCH_SIZE: 15
+};
+function parseDiffByFile(rawDiff) {
+  const sections = new Map;
+  const headerPattern = /^diff --git a\/(.+?) b\/(.+?)$/gm;
+  const positions = [];
+  for (let match = headerPattern.exec(rawDiff);match !== null; match = headerPattern.exec(rawDiff)) {
+    const aFile = match[1];
+    const bFile = match[2] ?? aFile;
+    positions.push({ aFile, bFile, start: match.index });
+  }
+  for (let i = 0;i < positions.length; i++) {
+    const { aFile, bFile, start } = positions[i];
+    const end = i + 1 < positions.length ? positions[i + 1].start : rawDiff.length;
+    const section = rawDiff.slice(start, end);
+    sections.set(aFile, section);
+    if (bFile && bFile !== aFile) {
+      sections.set(bFile, section);
+    }
+  }
+  return sections;
+}
+function extractDiffStats(diffSection) {
+  let added = 0;
+  let removed = 0;
+  for (const line of diffSection.split(`
+`)) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      added++;
+    if (line.startsWith("-") && !line.startsWith("---"))
+      removed++;
+  }
+  return { added, removed };
+}
+function createCompactDiff(files, rawDiff, maxTotalChars = BATCH_CONFIG.MAX_COMPACT_PAYLOAD) {
+  if (files.length === 0)
+    return "";
+  const diffSections = parseDiffByFile(rawDiff);
+  const perFileBudget = Math.min(BATCH_CONFIG.COMPACT_PER_FILE_CHARS, Math.floor(maxTotalChars / files.length));
+  const parts = [];
+  for (const file of files) {
+    const section = diffSections.get(file);
+    if (section) {
+      const stats = extractDiffStats(section);
+      const header = `[${file}] (+${stats.added}/-${stats.removed})`;
+      if (section.length <= perFileBudget) {
+        parts.push(`${header}
+${section}`);
+      } else {
+        const availableForBody = perFileBudget - header.length - 20;
+        if (availableForBody <= 0) {
+          parts.push(header);
+        } else {
+          const truncated = section.slice(0, availableForBody);
+          parts.push(`${header}
+${truncated}
+...(truncated)`);
+        }
+      }
+    } else {
+      parts.push(`[${file}] (new/binary file — no diff available)`);
+    }
+  }
+  const result = parts.join(`
+
+`);
+  return result.length > maxTotalChars ? `${result.slice(0, maxTotalChars - 15)}
+...(truncated)` : result;
+}
 async function checkCopilotAvailable() {
   try {
     const client = await getManagedClient();
@@ -1053,16 +1224,18 @@ function extractJson(raw) {
 }
 async function generateCommitMessage(diff, stagedFiles, model, convention = "clean-commit") {
   try {
+    const isLarge = stagedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD;
     const multiFileHint = stagedFiles.length > 1 ? `
 
 IMPORTANT: Multiple files are staged. Generate ONE commit message that captures the high-level purpose of ALL changes together. Focus on the overall intent, not individual file changes. Be specific but concise — do not list every file.` : "";
+    const diffContent = isLarge ? createCompactDiff(stagedFiles, diff) : diff.slice(0, 4000);
     const userMessage = `Generate a commit message for these staged changes:
 
-Files: ${stagedFiles.join(", ")}
+Files (${stagedFiles.length}): ${stagedFiles.join(", ")}
 
 Diff:
-${diff.slice(0, 4000)}${multiFileHint}`;
-    const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
+${diffContent}${multiFileHint}`;
+    const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model, isLarge ? COPILOT_LONG_TIMEOUT_MS : COPILOT_TIMEOUT_MS);
     return result?.trim() ?? null;
   } catch {
     return null;
@@ -1111,16 +1284,23 @@ ${conflictDiff.slice(0, 4000)}`;
   }
 }
 async function generateCommitGroups(files, diffs, model, convention = "clean-commit") {
+  const isLarge = files.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD;
+  const diffContent = isLarge ? createCompactDiff(files, diffs) : diffs.slice(0, 6000);
+  const largeHint = isLarge ? `
+
+NOTE: This is a large changeset (${files.length} files). Compact diffs are provided for every file. Focus on creating well-organized logical groups.` : "";
   const userMessage = `Group these changed files into logical atomic commits:
 
 Files:
 ${files.join(`
 `)}
 
-Diffs (truncated):
-${diffs.slice(0, 6000)}`;
+Diffs:
+${diffContent}${largeHint}`;
   const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
   if (!result) {
+    if (isLarge)
+      return generateCommitGroupsInBatches(files, diffs, model, convention);
     throw new Error("AI returned an empty response");
   }
   const cleaned = extractJson(result);
@@ -1128,10 +1308,14 @@ ${diffs.slice(0, 6000)}`;
   try {
     parsed = JSON.parse(cleaned);
   } catch {
+    if (isLarge)
+      return generateCommitGroupsInBatches(files, diffs, model, convention);
     throw new Error(`AI response is not valid JSON. Raw start: "${result.slice(0, 120)}..."`);
   }
   const groups = parsed;
   if (!Array.isArray(groups) || groups.length === 0) {
+    if (isLarge)
+      return generateCommitGroupsInBatches(files, diffs, model, convention);
     throw new Error("AI response was not a valid JSON array of commit groups");
   }
   for (const group of groups) {
@@ -1141,7 +1325,63 @@ ${diffs.slice(0, 6000)}`;
   }
   return groups;
 }
+async function generateCommitGroupsInBatches(files, diffs, model, convention = "clean-commit") {
+  const batchSize = BATCH_CONFIG.FALLBACK_BATCH_SIZE;
+  const allGroups = [];
+  const diffSections = parseDiffByFile(diffs);
+  for (let i = 0;i < files.length; i += batchSize) {
+    const batchFiles = files.slice(i, i + batchSize);
+    const batchDiff = batchFiles.map((f) => diffSections.get(f) ?? "").filter(Boolean).join(`
+`);
+    const batchDiffContent = batchFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? createCompactDiff(batchFiles, batchDiff) : batchDiff.slice(0, 6000);
+    const batchNum = Math.floor(i / batchSize) + 1;
+    const totalBatches = Math.ceil(files.length / batchSize);
+    const userMessage = `Group these changed files into logical atomic commits:
+
+Files:
+${batchFiles.join(`
+`)}
+
+Diffs:
+${batchDiffContent}
+
+NOTE: Processing batch ${batchNum}/${totalBatches} of a large changeset. Group only the files listed above.`;
+    try {
+      const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
+      if (!result)
+        continue;
+      const cleaned = extractJson(result);
+      const parsed = JSON.parse(cleaned);
+      if (Array.isArray(parsed)) {
+        for (const group of parsed) {
+          if (Array.isArray(group.files) && typeof group.message === "string") {
+            const batchFileSet = new Set(batchFiles);
+            const filteredFiles = group.files.filter((f) => batchFileSet.has(f));
+            if (filteredFiles.length > 0) {
+              allGroups.push({ ...group, files: filteredFiles });
+            }
+          }
+        }
+      }
+    } catch {}
+  }
+  const groupedFiles = new Set(allGroups.flatMap((g) => g.files));
+  const ungrouped = files.filter((f) => !groupedFiles.has(f));
+  if (ungrouped.length > 0) {
+    allGroups.push({
+      files: ungrouped,
+      message: `chore: update ${ungrouped.length} remaining file${ungrouped.length !== 1 ? "s" : ""}`
+    });
+  }
+  if (allGroups.length === 0) {
+    throw new Error("AI could not group any files even with batch processing");
+  }
+  return allGroups;
+}
 async function regenerateAllGroupMessages(groups, diffs, model, convention = "clean-commit") {
+  const totalFiles = groups.reduce((sum, g) => sum + g.files.length, 0);
+  const isLarge = totalFiles >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD;
+  const diffContent = isLarge ? createCompactDiff(groups.flatMap((g) => g.files), diffs) : diffs.slice(0, 6000);
   const groupSummary = groups.map((g, i) => `Group ${i + 1}: [${g.files.join(", ")}]`).join(`
 `);
   const userMessage = `Regenerate ONLY the commit messages for these pre-defined file groups. Do NOT change the file groupings.
@@ -1149,8 +1389,8 @@ async function regenerateAllGroupMessages(groups, diffs, model, convention = "cl
 Groups:
 ${groupSummary}
 
-Diffs (truncated):
-${diffs.slice(0, 6000)}`;
+Diffs:
+${diffContent}`;
   const result = await callCopilot(getGroupingSystemPrompt(convention), userMessage, model, COPILOT_LONG_TIMEOUT_MS);
   if (!result)
     return groups;
@@ -1169,12 +1409,14 @@ ${diffs.slice(0, 6000)}`;
 }
 async function regenerateGroupMessage(files, diffs, model, convention = "clean-commit") {
   try {
+    const isLarge = files.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD;
+    const diffContent = isLarge ? createCompactDiff(files, diffs) : diffs.slice(0, 4000);
     const userMessage = `Generate a single commit message for these files:
 
 Files: ${files.join(", ")}
 
 Diff:
-${diffs.slice(0, 4000)}`;
+${diffContent}`;
     const result = await callCopilot(getCommitSystemPrompt(convention), userMessage, model);
     return result?.trim() ?? null;
   } catch {
@@ -1732,7 +1974,8 @@ ${pc6.bold("Changed files:")}`);
         warn(`AI unavailable: ${copilotError}`);
         warn("Falling back to manual commit message entry.");
       } else {
-        const spinner = createSpinner("Generating commit message with AI...");
+        const spinnerMsg = stagedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? `Generating commit message with AI (${stagedFiles.length} files — using optimized batching)...` : "Generating commit message with AI...";
+        const spinner = createSpinner(spinnerMsg);
         commitMessage = await generateCommitMessage(diff, stagedFiles, args.model, config.commitConvention);
         if (commitMessage) {
           spinner.success("AI commit message generated.");
@@ -1823,7 +2066,7 @@ ${pc6.bold("Changed files:")}`);
   for (const f of changedFiles) {
     console.log(`  ${pc6.dim("•")} ${f}`);
   }
-  const spinner = createSpinner(`Asking AI to group ${changedFiles.length} file(s) into logical commits...`);
+  const spinner = createSpinner(changedFiles.length >= BATCH_CONFIG.LARGE_CHANGESET_THRESHOLD ? `Asking AI to group ${changedFiles.length} file(s) into logical commits (using optimized batching)...` : `Asking AI to group ${changedFiles.length} file(s) into logical commits...`);
   const diffs = await getFullDiffForFiles(changedFiles);
   if (!diffs.trim()) {
     spinner.stop();
@@ -2001,8 +2244,8 @@ import pc7 from "picocolors";
 // package.json
 var package_default = {
   name: "contribute-now",
-  version: "0.4.0",
-  description: "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
+  version: "0.4.1-dev.23d6614",
+  description: "Developer CLI that automates git workflows — branching, syncing, committing, and PRs — with multi-workflow and commit convention support.",
   type: "module",
   bin: {
     contrib: "dist/index.js",
@@ -2019,9 +2262,10 @@ var package_default = {
     lint: "biome check .",
     "lint:fix": "biome check --write .",
     format: "biome format --write .",
-    "www:dev": "bun run --cwd www dev",
-    "www:build": "bun run --cwd www build",
-    "www:preview": "bun run --cwd www preview"
+    "landing:install": "bun install --cwd landing",
+    "landing:dev": "bun run --cwd landing dev",
+    "landing:build": "bun run --cwd landing build",
+    "landing:preview": "bun run --cwd landing preview"
   },
   engines: {
     node: ">=18",
@@ -2519,7 +2763,19 @@ var log_default = defineCommand6({
     all: {
       type: "boolean",
       alias: "a",
-      description: "Show all branches, not just current",
+      description: "Show commits from all branches",
+      default: false
+    },
+    remote: {
+      type: "boolean",
+      alias: "r",
+      description: "Show only remote commits not yet pulled locally",
+      default: false
+    },
+    full: {
+      type: "boolean",
+      alias: "f",
+      description: "Show full commit history for the current branch",
       default: false
     },
     graph: {
@@ -2541,44 +2797,197 @@ var log_default = defineCommand6({
     }
     const config = readConfig();
     const count = args.count ? Number.parseInt(args.count, 10) : 20;
-    const showAll = args.all;
     const showGraph = args.graph;
     const targetBranch = args.branch;
+    let mode = "local";
+    if (args.all)
+      mode = "all";
+    else if (args.remote)
+      mode = "remote";
+    else if (args.full || targetBranch)
+      mode = "full";
     const protectedBranches = config ? getProtectedBranches(config) : ["main", "master"];
     const currentBranch = await getCurrentBranch();
+    const upstream = await getUpstreamRef();
+    let compareRef = upstream;
+    let usingFallback = false;
+    if (!compareRef) {
+      const fallback = await resolveBaseBranchRef(config);
+      if (fallback) {
+        compareRef = fallback;
+        usingFallback = true;
+      }
+    }
     heading("\uD83D\uDCDC commit log");
-    if (showGraph) {
-      const lines = await getLogGraph({ count, all: showAll, branch: targetBranch });
-      if (lines.length === 0) {
-        console.log(pc9.dim("  No commits found."));
+    printModeHeader(mode, currentBranch, compareRef, usingFallback);
+    if (mode === "local" || mode === "remote") {
+      if (!compareRef) {
         console.log();
+        console.log(pc9.yellow("  ⚠ Could not determine a comparison branch."));
+        console.log(pc9.dim("    No upstream tracking set and no remote base branch found."));
+        console.log(pc9.dim(`    Use ${pc9.bold("contrib log --full")} to see the full commit history instead.`));
+        console.log();
+        printGuidance();
         return;
       }
-      console.log();
-      for (const line of lines) {
-        console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
+      const hasCommits = await renderScopedLog({ mode, count, upstream: compareRef, showGraph, protectedBranches, currentBranch });
+      if (!hasCommits) {
+        printGuidance();
+        return;
       }
     } else {
-      const entries = await getLogEntries({ count, all: showAll, branch: targetBranch });
-      if (entries.length === 0) {
-        console.log(pc9.dim("  No commits found."));
-        console.log();
+      const hasCommits = await renderFullLog({ count, all: mode === "all", showGraph, targetBranch, protectedBranches, currentBranch });
+      if (!hasCommits) {
+        printGuidance();
         return;
       }
-      console.log();
-      for (const entry of entries) {
-        const hashStr = pc9.yellow(entry.hash);
-        const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
-        const subjectStr = colorizeSubject(entry.subject);
-        console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
+    }
+    printFooter(mode, count, targetBranch);
+    printGuidance();
+  }
+});
+async function resolveBaseBranchRef(config) {
+  if (!config) {
+    for (const candidate2 of ["origin/main", "origin/master"]) {
+      if (await branchExists(candidate2))
+        return candidate2;
+    }
+    return null;
+  }
+  const baseBranch = getBaseBranch(config);
+  const remote = config.origin ?? "origin";
+  const candidate = `${remote}/${baseBranch}`;
+  if (await branchExists(candidate))
+    return candidate;
+  for (const fallback of ["origin/main", "origin/master"]) {
+    if (fallback !== candidate && await branchExists(fallback))
+      return fallback;
+  }
+  return null;
+}
+function printModeHeader(mode, currentBranch, compareRef, usingFallback = false) {
+  const branch = currentBranch ?? "HEAD";
+  const fallbackNote = usingFallback ? pc9.yellow(" (no upstream — comparing against base branch)") : "";
+  console.log();
+  switch (mode) {
+    case "local":
+      console.log(pc9.dim(`  mode: ${pc9.bold("local")} — unpushed commits on ${pc9.bold(branch)}`) + fallbackNote);
+      if (compareRef) {
+        console.log(pc9.dim(`  comparing: ${pc9.bold(compareRef)} ➜ ${pc9.bold("HEAD")}`));
       }
+      break;
+    case "remote":
+      console.log(pc9.dim(`  mode: ${pc9.bold("remote")} — commits on remote not yet pulled into ${pc9.bold(branch)}`) + fallbackNote);
+      if (compareRef) {
+        console.log(pc9.dim(`  comparing: ${pc9.bold("HEAD")} ➜ ${pc9.bold(compareRef)}`));
+      }
+      break;
+    case "full":
+      console.log(pc9.dim(`  mode: ${pc9.bold("full")} — complete commit history for ${pc9.bold(branch)}`));
+      break;
+    case "all":
+      console.log(pc9.dim(`  mode: ${pc9.bold("all")} — commits across all branches`));
+      break;
+  }
+}
+async function renderScopedLog(options) {
+  const { mode, count, upstream, showGraph, protectedBranches, currentBranch } = options;
+  if (showGraph) {
+    const graphFn = mode === "local" ? getLocalCommitsGraph : getRemoteOnlyCommitsGraph;
+    const lines = await graphFn({ count, upstream });
+    if (lines.length === 0) {
+      printEmptyState(mode);
+      return false;
     }
     console.log();
-    console.log(pc9.dim(`  Showing ${count} most recent commits${showAll ? " (all branches)" : targetBranch ? ` (${targetBranch})` : ""}`));
-    console.log(pc9.dim(`  Use ${pc9.bold("contrib log -n 50")} for more, or ${pc9.bold("contrib log --all")} for all branches`));
+    for (const line of lines) {
+      console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
+    }
+  } else {
+    const entryFn = mode === "local" ? getLocalCommitsEntries : getRemoteOnlyCommitsEntries;
+    const entries = await entryFn({ count, upstream });
+    if (entries.length === 0) {
+      printEmptyState(mode);
+      return false;
+    }
     console.log();
+    for (const entry of entries) {
+      const hashStr = pc9.yellow(entry.hash);
+      const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
+      const subjectStr = colorizeSubject(entry.subject);
+      console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
+    }
   }
-});
+  return true;
+}
+function printEmptyState(mode) {
+  console.log();
+  if (mode === "local") {
+    console.log(pc9.dim("  No local unpushed commits — you're up to date with remote!"));
+  } else {
+    console.log(pc9.dim("  No remote-only commits — your local branch is up to date!"));
+  }
+  console.log();
+}
+async function renderFullLog(options) {
+  const { count, all, showGraph, targetBranch, protectedBranches, currentBranch } = options;
+  if (showGraph) {
+    const lines = await getLogGraph({ count, all, branch: targetBranch });
+    if (lines.length === 0) {
+      console.log(pc9.dim("  No commits found."));
+      console.log();
+      return false;
+    }
+    console.log();
+    for (const line of lines) {
+      console.log(`  ${colorizeGraphLine(line, protectedBranches, currentBranch)}`);
+    }
+  } else {
+    const entries = await getLogEntries({ count, all, branch: targetBranch });
+    if (entries.length === 0) {
+      console.log(pc9.dim("  No commits found."));
+      console.log();
+      return false;
+    }
+    console.log();
+    for (const entry of entries) {
+      const hashStr = pc9.yellow(entry.hash);
+      const refsStr = entry.refs ? ` ${colorizeRefs(entry.refs, protectedBranches, currentBranch)}` : "";
+      const subjectStr = colorizeSubject(entry.subject);
+      console.log(`  ${hashStr}${refsStr} ${subjectStr}`);
+    }
+  }
+  return true;
+}
+function printFooter(mode, count, targetBranch) {
+  console.log();
+  switch (mode) {
+    case "local":
+      console.log(pc9.dim(`  Showing up to ${count} unpushed commits`));
+      break;
+    case "remote":
+      console.log(pc9.dim(`  Showing up to ${count} remote-only commits`));
+      break;
+    case "full":
+      console.log(pc9.dim(`  Showing ${count} most recent commits${targetBranch ? ` (${targetBranch})` : ""}`));
+      break;
+    case "all":
+      console.log(pc9.dim(`  Showing ${count} most recent commits (all branches)`));
+      break;
+  }
+}
+function printGuidance() {
+  console.log();
+  console.log(pc9.dim("  ─── quick guide ───"));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log")}            local unpushed commits (default)`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --remote")}   commits on remote not yet pulled`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --full")}     full history for the current branch`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --all")}      commits across all branches`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log -n 50")}      change the commit limit (default: 20)`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log -b dev")}     view log for a specific branch`));
+  console.log(pc9.dim(`  ${pc9.bold("contrib log --no-graph")} flat list without graph lines`));
+  console.log();
+}
 function colorizeGraphLine(line, protectedBranches, currentBranch) {
   const match = line.match(/^([|/\\*\s_.-]*)([a-f0-9]{7,12})(\s+\(([^)]+)\))?\s*(.*)/);
   if (!match) {
@@ -2660,6 +3069,43 @@ function colorizeSubject(subject) {
 // src/commands/setup.ts
 import { defineCommand as defineCommand7 } from "citty";
 import pc10 from "picocolors";
+async function shouldContinueSetupWithExistingConfig(options) {
+  const {
+    existingConfig,
+    hasConfigFile,
+    confirm: confirm2,
+    ensureIgnored,
+    onInfo,
+    onWarn,
+    onSuccess,
+    summary
+  } = options;
+  if (existingConfig) {
+    onInfo("Existing .contributerc.json detected:");
+    summary(existingConfig);
+    const shouldContinue = await confirm2("Continue setup and overwrite existing config?");
+    if (!shouldContinue) {
+      if (ensureIgnored()) {
+        onInfo("Added .contributerc.json to .gitignore to avoid committing personal config.");
+      }
+      onSuccess("Keeping existing setup.");
+      return false;
+    }
+    return true;
+  }
+  if (hasConfigFile) {
+    onWarn("Found .contributerc.json but it appears invalid.");
+    const shouldContinue = await confirm2("Continue setup and overwrite invalid config?");
+    if (!shouldContinue) {
+      if (ensureIgnored()) {
+        onInfo("Added .contributerc.json to .gitignore to avoid committing personal config.");
+      }
+      onInfo("Keeping existing file. Run setup again when ready to repair it.");
+      return false;
+    }
+  }
+  return true;
+}
 var setup_default = defineCommand7({
   meta: {
     name: "setup",
@@ -2671,6 +3117,20 @@ var setup_default = defineCommand7({
       process.exit(1);
     }
     heading("\uD83D\uDD27 contribute-now setup");
+    const existingConfig = readConfig();
+    const shouldContinue = await shouldContinueSetupWithExistingConfig({
+      existingConfig,
+      hasConfigFile: configExists(),
+      confirm: confirmPrompt,
+      ensureIgnored: ensureGitignored,
+      onInfo: info,
+      onWarn: warn,
+      onSuccess: success,
+      summary: logConfigSummary
+    });
+    if (!shouldContinue) {
+      return;
+    }
     const workflowChoice = await selectPrompt("Which git workflow does this project use?", [
       "Clean Flow — main + dev, squash features into dev, merge dev into main (recommended)",
       "GitHub Flow — main + feature branches, squash/merge into main",
@@ -2700,31 +3160,42 @@ var setup_default = defineCommand7({
     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)";
+    const roleSpinner = createSpinner("Detecting your role...");
+    try {
+      roleSpinner.update("Checking GitHub CLI and auth...");
+      const ghInstalled = await checkGhInstalled();
+      if (ghInstalled && await checkGhAuth()) {
+        roleSpinner.update("Inspecting repository relationship (fork/permissions)...");
+        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) {
+        roleSpinner.update("Analyzing git remotes...");
+        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)";
+        }
       }
+      roleSpinner.success("Role detection complete.");
+    } catch {
+      roleSpinner.fail("Role detection failed; falling back to manual selection.");
+      detectedRole = null;
+      detectionSource = "";
     }
     if (detectedRole === null) {
       const roleChoice = await selectPrompt("What is your role in this project?", [
@@ -2742,16 +3213,20 @@ var setup_default = defineCommand7({
       }
     }
     const defaultConfig = getDefaultConfig();
-    const mainBranch = await inputPrompt("Main branch name", defaultConfig.mainBranch);
+    info(pc10.dim("Tip: press Enter to keep the default branch name shown in each prompt."));
+    const mainBranchDefault = defaultConfig.mainBranch;
+    const mainBranch = await inputPrompt(`Main branch name (default: ${mainBranchDefault} — press Enter to keep)`, mainBranchDefault);
     let devBranch;
     if (hasDevBranch(workflow)) {
       const defaultDev = workflow === "git-flow" ? "develop" : "dev";
-      devBranch = await inputPrompt("Dev/develop branch name", defaultDev);
+      devBranch = await inputPrompt(`Dev/develop branch name (default: ${defaultDev} — press Enter to keep)`, defaultDev);
     }
-    const originRemote = await inputPrompt("Origin remote name", defaultConfig.origin);
+    const originRemoteDefault = defaultConfig.origin;
+    const originRemote = await inputPrompt(`Origin remote name (default: ${originRemoteDefault} — press Enter to keep)`, originRemoteDefault);
     let upstreamRemote = defaultConfig.upstream;
     if (detectedRole === "contributor") {
-      upstreamRemote = await inputPrompt("Upstream remote name", defaultConfig.upstream);
+      const upstreamRemoteDefault = defaultConfig.upstream;
+      upstreamRemote = await inputPrompt(`Upstream remote name (default: ${upstreamRemoteDefault} — press Enter to keep)`, upstreamRemoteDefault);
       if (!remotes.includes(upstreamRemote)) {
         warn(`Remote "${upstreamRemote}" not found.`);
         const originUrl = await getRemoteUrl(originRemote);
@@ -2799,9 +3274,8 @@ var setup_default = defineCommand7({
         warn("Config was saved — verify the branch name and re-run setup if needed.");
       }
     }
-    if (!isGitignored()) {
-      warn(".contributerc.json is not in .gitignore. Add it to avoid committing personal config.");
-      warn('  echo ".contributerc.json" >> .gitignore');
+    if (ensureGitignored()) {
+      info("Added .contributerc.json to .gitignore to avoid committing personal config.");
     }
     console.log();
     info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
@@ -2815,6 +3289,17 @@ var setup_default = defineCommand7({
     info(`Origin: ${pc10.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc10.bold(config.upstream)}` : ""}`);
   }
 });
+function logConfigSummary(config) {
+  info(`Workflow: ${pc10.bold(WORKFLOW_DESCRIPTIONS[config.workflow])}`);
+  info(`Convention: ${pc10.bold(CONVENTION_DESCRIPTIONS[config.commitConvention])}`);
+  info(`Role: ${pc10.bold(config.role)}`);
+  if (config.devBranch) {
+    info(`Main: ${pc10.bold(config.mainBranch)} | Dev: ${pc10.bold(config.devBranch)}`);
+  } else {
+    info(`Main: ${pc10.bold(config.mainBranch)}`);
+  }
+  info(`Origin: ${pc10.bold(config.origin)}${config.role === "contributor" ? ` | Upstream: ${pc10.bold(config.upstream)}` : ""}`);
+}
 
 // src/commands/start.ts
 import { defineCommand as defineCommand8 } from "citty";
@@ -2983,10 +3468,20 @@ var status_default = defineCommand9({
       const devLine = formatStatus(config.devBranch, devRemoteRef, devDiv.ahead, devDiv.behind);
       console.log(devLine);
     }
-    if (currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
+    const protectedBranches = getProtectedBranches(config);
+    const isFeatureBranch = currentBranch && !protectedBranches.includes(currentBranch);
+    let branchStatus = null;
+    if (isFeatureBranch) {
       const branchDiv = await getDivergence(currentBranch, baseBranch);
       const branchLine = formatStatus(currentBranch, baseBranch, branchDiv.ahead, branchDiv.behind);
       console.log(branchLine + pc12.dim(` (current ${pc12.green("*")})`));
+      branchStatus = await detectBranchStatus(currentBranch, baseBranch, config);
+      if (branchStatus.merged) {
+        console.log(`  ${pc12.green("✓")}  ${pc12.green("Branch merged")} — ${pc12.dim(branchStatus.mergedReason ?? "all commits reachable from base")}`);
+      }
+      if (branchStatus.stale) {
+        console.log(`  ${pc12.yellow("⏳")}  ${pc12.yellow("Branch is stale")} — ${pc12.dim(`last commit ${branchStatus.staleDaysAgo} days ago`)}`);
+      }
     } else if (currentBranch) {
       console.log(pc12.dim(`  (on ${pc12.bold(currentBranch)} branch)`));
     }
@@ -3021,10 +3516,16 @@ var status_default = defineCommand9({
     if (fileStatus.modified.length > 0 || fileStatus.untracked.length > 0) {
       tips.push(`Run ${pc12.bold("contrib commit")} to stage and commit changes`);
     }
-    if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0 && currentBranch && currentBranch !== mainBranch && currentBranch !== config.devBranch) {
-      const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
-      if (branchDiv.ahead > 0) {
-        tips.push(`Run ${pc12.bold("contrib submit")} to push and create/update your PR`);
+    if (isFeatureBranch && branchStatus) {
+      if (branchStatus.merged) {
+        tips.push(`Run ${pc12.bold("contrib clean")} to delete this merged branch`);
+      } else if (branchStatus.stale) {
+        tips.push(`Run ${pc12.bold("contrib sync")} to rebase on latest changes, or ${pc12.bold("contrib clean")} if no longer needed`);
+      } else if (fileStatus.staged.length === 0 && fileStatus.modified.length === 0 && fileStatus.untracked.length === 0) {
+        const branchDiv = await getDivergence(currentBranch, `${origin}/${currentBranch}`);
+        if (branchDiv.ahead > 0) {
+          tips.push(`Run ${pc12.bold("contrib submit")} to push and create/update your PR`);
+        }
       }
     }
     if (tips.length > 0) {
@@ -3050,6 +3551,48 @@ function formatStatus(branch, base, ahead, behind) {
   }
   return `  ${pc12.red("⚡")}  ${label} ${pc12.yellow(`${ahead} ahead`)}${pc12.dim(", ")}${pc12.red(`${behind} behind`)} ${pc12.dim(base)}`;
 }
+var STALE_THRESHOLD_DAYS = 14;
+async function detectBranchStatus(branch, baseBranch, config) {
+  const result = { merged: false, mergedReason: null, stale: false, staleDaysAgo: null };
+  const div = await getDivergence(branch, baseBranch);
+  const hasWork = div.ahead > 0;
+  if (hasWork) {
+    if (await isBranchMergedInto(branch, baseBranch)) {
+      result.merged = true;
+      result.mergedReason = `all commits reachable from ${baseBranch}`;
+      return result;
+    }
+    const mergedBranches = await getMergedBranches(baseBranch);
+    if (mergedBranches.includes(branch)) {
+      result.merged = true;
+      result.mergedReason = `listed in merged branches of ${baseBranch}`;
+      return result;
+    }
+  }
+  const goneBranches = await getGoneBranches();
+  if (goneBranches.includes(branch)) {
+    result.merged = true;
+    result.mergedReason = "remote branch deleted (likely squash-merged)";
+    return result;
+  }
+  if (await checkGhInstalled()) {
+    const mergedPR = await getMergedPRForBranch(branch);
+    if (mergedPR) {
+      result.merged = true;
+      result.mergedReason = `PR #${mergedPR.number} was merged`;
+      return result;
+    }
+  }
+  const lastDate = await getLastCommitDate(branch);
+  if (lastDate) {
+    const daysAgo = Math.floor((Date.now() - new Date(lastDate).getTime()) / (1000 * 60 * 60 * 24));
+    if (daysAgo >= STALE_THRESHOLD_DAYS) {
+      result.stale = true;
+      result.staleDaysAgo = daysAgo;
+    }
+  }
+  return result;
+}
 
 // src/commands/submit.ts
 import { defineCommand as defineCommand10 } from "citty";
@@ -3343,6 +3886,25 @@ var submit_default = defineCommand10({
         return;
       }
     }
+    if (ghInstalled && ghAuthed) {
+      const existingPR = await getPRForBranch(currentBranch);
+      if (existingPR) {
+        info(`Pushing ${pc13.bold(currentBranch)} to ${origin}...`);
+        const pushResult2 = await pushSetUpstream(origin, currentBranch);
+        if (pushResult2.exitCode !== 0) {
+          error(`Failed to push: ${pushResult2.stderr}`);
+          if (pushResult2.stderr.includes("rejected") || pushResult2.stderr.includes("non-fast-forward")) {
+            warn("The remote branch has diverged. Try:");
+            info(`  git pull --rebase ${origin} ${currentBranch}`);
+            info("  Then run `contrib submit` again.");
+          }
+          process.exit(1);
+        }
+        success(`Pushed changes to existing PR #${existingPR.number}: ${pc13.bold(existingPR.title)}`);
+        console.log(`  ${pc13.cyan(existingPR.url)}`);
+        return;
+      }
+    }
     let prTitle = null;
     let prBody = null;
     async function tryGenerateAI() {
@@ -3476,12 +4038,6 @@ ${pc13.dim("AI body preview:")}`);
       }
       return;
     }
-    const existingPR = await getPRForBranch(currentBranch);
-    if (existingPR) {
-      success(`Pushed changes to existing PR #${existingPR.number}: ${pc13.bold(existingPR.title)}`);
-      console.log(`  ${pc13.cyan(existingPR.url)}`);
-      return;
-    }
     if (submitAction === "fill") {
       const fillResult = await createPRFill(baseBranch, args.draft);
       if (fillResult.exitCode !== 0) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "contribute-now",
-  "version": "0.4.0",
-  "description": "Git workflow CLI for squash-merge two-branch models. Keeps dev in sync with main after squash merges.",
+  "version": "0.4.1-dev.23d6614",
+  "description": "Developer CLI that automates git workflows — branching, syncing, committing, and PRs — with multi-workflow and commit convention support.",
   "type": "module",
   "bin": {
     "contrib": "dist/index.js",
@@ -18,9 +18,10 @@
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",
-    "www:dev": "bun run --cwd www dev",
-    "www:build": "bun run --cwd www build",
-    "www:preview": "bun run --cwd www preview"
+    "landing:install": "bun install --cwd landing",
+    "landing:dev": "bun run --cwd landing dev",
+    "landing:build": "bun run --cwd landing build",
+    "landing:preview": "bun run --cwd landing preview"
   },
   "engines": {
     "node": ">=18",