otto-git-cli 4.0.4

package/src/commands/settings.js

@@ -0,0 +1,65 @@
+import { select, text, isCancel } from "@clack/prompts";
+import { OPENAI_API_KEY, SHEET_WEBHOOK_URL, updateConfig } from "../config.js";
+import pc from "picocolors";
+
+export async function flowSettings() {
+  while (true) {
+    const maskKey = (key) =>
+      key ? `${key.substring(0, 3)}...${key.substring(key.length - 4)}` : "Not Set";
+    const maskUrl = (url) =>
+      url ? `${url.substring(0, 20)}...` : "Not Set";
+
+    const selection = await select({
+      message: "⚙️ Settings",
+      options: [
+        {
+          value: "openai",
+          label: "🤖 OpenAI API Key",
+          hint: maskKey(OPENAI_API_KEY),
+        },
+        {
+          value: "sheet",
+          label: "📊 Google Sheets URL",
+          hint: maskUrl(SHEET_WEBHOOK_URL),
+        },
+        { value: "back", label: "🔙 Back" },
+      ],
+    });
+
+    if (isCancel(selection) || selection === "back") return;
+
+    if (selection === "openai") {
+      const newKey = await text({
+        message: "Enter new OpenAI API Key:",
+        initialValue: OPENAI_API_KEY || "",
+        placeholder: "sk-...",
+        validate: (value) => {
+          if (!value) return "API Key is required.";
+          if (!value.startsWith("sk-")) return "Key usually starts with sk-";
+        },
+      });
+
+      if (!isCancel(newKey)) {
+        updateConfig("OPENAI_API_KEY", newKey);
+        console.log(pc.green("✔ OpenAI API Key updated."));
+      }
+    }
+
+    if (selection === "sheet") {
+      const newUrl = await text({
+        message: "Enter Google Sheet Webhook URL:",
+        initialValue: SHEET_WEBHOOK_URL || "",
+        placeholder: "https://script.google.com/...",
+        validate: (val) => {
+          if (!val) return "URL is required.";
+          if (!val.startsWith("http")) return "Invalid URL.";
+        },
+      });
+
+      if (!isCancel(newUrl)) {
+        updateConfig("GOOGLE_SHEET_WEBHOOK_URL", newUrl);
+        console.log(pc.green("✔ Google Sheet URL updated."));
+      }
+    }
+  }
+}

package/src/commands/stash.js

@@ -0,0 +1,73 @@
+import { spinner, select, text, isCancel, note } from "@clack/prompts";
+import pc from "picocolors";
+import { git } from "../git/index.js";
+import { sh } from "../utils/shell.js";
+
+/**
+ * Stash manager flow - save and pop stashes
+ */
+export async function flowStash() {
+  if (!git.isRepo()) {
+    note("Not a git repository.", "Error");
+    return;
+  }
+
+  const action = await select({
+    message: "Stash Manager",
+    options: [
+      { value: "save", label: "💾 Save", hint: "Stash current changes" },
+      { value: "pop", label: "🥡 Pop", hint: "Apply saved stash" },
+    ],
+  });
+
+  if (isCancel(action)) return;
+
+  if (action === "save") {
+    try {
+      const msg = await text({
+        message: "Stash Message (Optional)",
+        placeholder: "WIP: Refactoring...",
+      });
+      if (isCancel(msg)) return;
+
+      const s = spinner();
+      s.start(pc.dim("Saving stash..."));
+      git.stashSave(msg || "Otto Stash");
+      s.stop(pc.green("✔ Stashed successfully"));
+    } catch (e) {
+      note(e.message, "⚠ Info");
+    }
+  }
+
+  if (action === "pop") {
+    const stashes = git.stashList();
+    if (stashes.length === 0) {
+      note("No stashes found.", "ℹ Empty");
+      return;
+    }
+
+    const target = await select({
+      message: "Select Stash to Pop",
+      options: stashes.map((s) => ({
+        value: s.ref,
+        label: s.msg,
+        hint: s.ref,
+      })),
+    });
+
+    if (isCancel(target)) return;
+
+    const s = spinner();
+    s.start(pc.dim(`Popping ${target}...`));
+    try {
+      sh(`git stash pop ${target}`);
+      s.stop(pc.green("✔ Popped successfully"));
+    } catch (e) {
+      s.stop(pc.red("✖ Pop resulted in conflicts"));
+      note(
+        "Changes are applied but there are merge conflicts. Resolve them manually.",
+        "⚠ Conflict"
+      );
+    }
+  }
+}

package/src/commands/sync.js

@@ -0,0 +1,49 @@
+import { spinner, note } from "@clack/prompts";
+import pc from "picocolors";
+import { git } from "../git/index.js";
+import { sh } from "../utils/shell.js";
+
+/**
+ * Sync flow - fetch and pull from origin
+ */
+export async function flowSync() {
+  if (!git.isRepo()) {
+    note("Not a git repository.", "Error");
+    return;
+  }
+
+  const s = spinner();
+  s.start(pc.blue("📡 Fetching origin..."));
+
+  try {
+    sh("git fetch origin");
+    const curr = git.branch();
+
+    // Check if branch exists on remote to avoid error
+    const remoteRef = sh(`git ls-remote --heads origin ${curr}`, true);
+
+    if (!remoteRef) {
+      s.stop(pc.yellow("⚠ No remote branch"));
+      note(
+        `Branch 'origin/${curr}' does not exist.\nPush your branch first to enable syncing.`,
+        "ℹ Info"
+      );
+      return;
+    }
+
+    s.message(pc.blue(`🔄 Pulling origin/${curr}...`));
+
+    // Explicitly pull from the remote matching current branch
+    sh(`git pull origin ${curr}`);
+
+    // Try to fix the upstream config for next time (silent)
+    try {
+      sh(`git branch --set-upstream-to=origin/${curr} ${curr}`, true);
+    } catch {}
+
+    s.stop(pc.green("✔ Sync Complete"));
+  } catch (e) {
+    s.stop(pc.red("✖ Sync Failed"));
+    note(e.message, "Git Error");
+  }
+}

package/src/commands/undo.js

@@ -0,0 +1,77 @@
+import { spinner, select, confirm, isCancel, note } from "@clack/prompts";
+import pc from "picocolors";
+import { git } from "../git/index.js";
+import { sh } from "../utils/shell.js";
+
+/**
+ * Undo/Rollback flow - reset to a previous commit
+ */
+export async function flowUndo() {
+  if (!git.isRepo()) {
+    note("Not a git repository.", "Error");
+    return;
+  }
+
+  const s = spinner();
+  s.start(pc.dim("Fetching history"));
+  const history = git.log(15);
+  s.stop(pc.dim("History loaded"));
+
+  if (!history.length) {
+    note("No commit history found to undo.", "ℹ Empty");
+    return;
+  }
+
+  const targetHash = await select({
+    message: "Reset branch to which commit?",
+    options: history.map((c, i) => {
+      const label = i === 0 ? `${c.msg} (Current)` : c.msg;
+      return {
+        value: c.hash,
+        label: `${pc.cyan(c.hash)} ${label}`,
+        hint: `${c.author}, ${c.time}`,
+      };
+    }),
+  });
+
+  if (isCancel(targetHash)) return;
+
+  if (targetHash === history[0].hash) {
+    note("You selected the current commit. No changes made.", "ℹ Info");
+    return;
+  }
+
+  const resetMode = await select({
+    message: "How should we reset?",
+    options: [
+      { value: "--soft", label: "🧸 Soft Reset", hint: "Keep changes staged" },
+      {
+        value: "--mixed",
+        label: "🚧 Mixed Reset",
+        hint: "Keep changes in working dir",
+      },
+      { value: "--hard", label: "🧨 Hard Reset", hint: "DESTROY changes" },
+    ],
+  });
+
+  if (isCancel(resetMode)) return;
+
+  if (resetMode === "--hard") {
+    const safe = await confirm({
+      message: pc.red("⚠️  This will delete all uncommitted changes. Sure?"),
+    });
+    if (!safe || isCancel(safe)) return;
+  }
+
+  const r = spinner();
+  r.start(pc.yellow(`Resetting to ${targetHash}...`));
+
+  try {
+    sh(`git reset ${resetMode} ${targetHash}`);
+    r.stop(pc.green(`✔ Reset complete (${resetMode})`));
+    note(`HEAD is now at ${targetHash}`, "ℹ Reset Info");
+  } catch (e) {
+    r.stop(pc.red("✖ Reset failed"));
+    console.error(e.message);
+  }
+}

package/src/commands/updates.js

@@ -0,0 +1,57 @@
+import { confirm, isCancel, spinner } from "@clack/prompts";
+import pc from "picocolors";
+import { git } from "../git/index.js";
+import { ui } from "../ui/index.js";
+
+/**
+ * Check for updates and offer to pull if behind
+ */
+export async function checkForUpdates() {
+  if (!git.isRepo()) return;
+
+  try {
+    const { sh } = await import("../utils/shell.js");
+    sh("git fetch", true);
+  } catch {
+    return;
+  }
+
+  let behind = 0;
+  const current = git.branch();
+  const defaultBr = git.defaultBranch();
+
+  // Smart check: If on main, check against origin/main regardless of upstream config
+  if (
+    defaultBr &&
+    (current === "main" ||
+      current === "master" ||
+      current === defaultBr.replace("origin/", ""))
+  ) {
+    behind = parseInt(git.commitsBehind(defaultBr)) || 0;
+  } else {
+    behind = git.upstreamBehindCount();
+  }
+
+  if (behind > 0) {
+    const shouldPull = await confirm({
+      message: `Your branch is behind by ${behind} commits. Pull them?`,
+    });
+
+    if (isCancel(shouldPull)) process.exit(0);
+
+    if (shouldPull) {
+      const { sh } = await import("../utils/shell.js");
+      const s = spinner();
+      s.start(pc.blue("🔄 Pulling latest changes..."));
+      try {
+        sh(`git pull origin ${current}`);
+        s.stop(pc.green("✔ Updated"));
+        ui.banner();
+      } catch (e) {
+        s.stop(pc.red("✖ Pull Failed"));
+        const { note } = await import("@clack/prompts");
+        note(e.message);
+      }
+    }
+  }
+}

package/src/config.js

@@ -0,0 +1,46 @@
+import dotenv from "dotenv";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+dotenv.config();
+
+const HOMEDIR = os.homedir();
+const CONFIG_DIR = path.join(HOMEDIR, ".otto-cli");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+
+function loadGlobalConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf8"));
+    } catch (e) {
+      return {};
+    }
+  }
+  return {};
+}
+
+function saveGlobalConfig(newConfig) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+}
+
+const globalConf = loadGlobalConfig();
+
+// --- Configuration & Helpers ---
+export let SHEET_WEBHOOK_URL =
+  process.env.GOOGLE_SHEET_WEBHOOK_URL || globalConf.GOOGLE_SHEET_WEBHOOK_URL;
+export let OPENAI_API_KEY =
+  process.env.OPENAI_API_KEY || globalConf.OPENAI_API_KEY;
+export const PM = fs.existsSync("pnpm-lock.yaml") ? "pnpm" : "npm";
+
+export function updateConfig(key, value) {
+  const current = loadGlobalConfig();
+  const updated = { ...current, [key]: value };
+  saveGlobalConfig(updated);
+
+  if (key === "GOOGLE_SHEET_WEBHOOK_URL") SHEET_WEBHOOK_URL = value;
+  if (key === "OPENAI_API_KEY") OPENAI_API_KEY = value;
+}

package/src/git/index.js

@@ -0,0 +1,120 @@
+import { sh } from "../utils/shell.js";
+
+/**
+ * Git helper functions
+ */
+export const git = {
+  isRepo: () => sh("git rev-parse --is-inside-work-tree", true) === "true",
+
+  branch: () => {
+    if (!git.isRepo()) return "no-git";
+    const b = sh("git symbolic-ref --short -q HEAD", true);
+    if (b) return b;
+    const d = sh("git rev-parse --short HEAD", true);
+    return d ? `detached@${d}` : "unborn";
+  },
+
+  defaultBranch: () => {
+    if (!git.isRepo()) return null;
+    try {
+      sh("git rev-parse --verify origin/main");
+      return "origin/main";
+    } catch {
+      try {
+        sh("git rev-parse --verify origin/master");
+        return "origin/master";
+      } catch {
+        return "main";
+      }
+    }
+  },
+
+  commitInfo: (ref) => {
+    try {
+      const out = sh(`git log -1 --format="%h|%s|%ar" ${ref}`, true);
+      if (!out) return null;
+      const [hash, msg, time] = out.split("|");
+      return { hash, msg, time };
+    } catch {
+      return null;
+    }
+  },
+
+  commitsBehind: (target) => {
+    try {
+      return sh(`git rev-list --count HEAD..${target}`, true);
+    } catch {
+      return "0";
+    }
+  },
+
+  upstreamBehindCount: () => {
+    if (!git.isRepo()) return 0;
+    try {
+      const count = sh("git rev-list --count HEAD..@{u}", true);
+      return parseInt(count) || 0;
+    } catch {
+      return 0;
+    }
+  },
+
+  user: () => sh("git config user.name", true) || "Ghost",
+
+  diff: (staged = true) =>
+    sh(`git diff ${staged ? "--cached" : ""} --stat`, true),
+
+  rawDiff: () => sh("git diff --cached", true),
+
+  // Auto-stash for switching branches
+  stash: () => {
+    if (!git.isRepo()) return false;
+    const isDirty = sh("git status --porcelain", true).length > 0;
+    if (!isDirty) return false;
+    sh('git stash push -m "Otto Auto-Switch"', true);
+    return true;
+  },
+
+  // Manual stash with message
+  stashSave: (msg = "Otto Stash") => {
+    const isDirty = sh("git status --porcelain", true).length > 0;
+    if (!isDirty) throw new Error("No local changes to stash");
+    sh(`git stash push -m "${msg}"`);
+    return true;
+  },
+
+  // List all stashes
+  stashList: () => {
+    const out = sh("git stash list", true);
+    if (!out) return [];
+    // Output: stash@{0}: On main: message...
+    return out.split("\n").map((line) => {
+      const firstColon = line.indexOf(":");
+      const ref = line.substring(0, firstColon);
+      const msg = line.substring(firstColon + 1).trim();
+      return { ref, msg };
+    });
+  },
+
+  pop: () => {
+    if (!git.isRepo()) return false;
+    try {
+      sh("git stash pop");
+      return true;
+    } catch {
+      return false;
+    }
+  },
+
+  log: (limit = 10) => {
+    if (!git.isRepo()) return [];
+    const out = sh(
+      `git log -n ${limit} --pretty=format:"%h|%s|%an|%ar"`,
+      true
+    );
+    if (!out) return [];
+    return out.split("\n").map((line) => {
+      const [hash, msg, author, time] = line.split("|");
+      return { hash, msg, author, time };
+    });
+  },
+};

package/src/index.js

@@ -0,0 +1,117 @@
+import { Command } from "commander";
+import { select, isCancel, outro } from "@clack/prompts";
+import { ui } from "./ui/index.js";
+import { ensureConfig } from "./utils/setup.js";
+import {
+  checkForUpdates,
+  flowRelease,
+  flowBranch,
+  flowStash,
+  flowUndo,
+  flowSync,
+  flowBuild,
+  flowSettings,
+} from "./commands/index.js";
+
+/**
+ * Main interactive menu loop
+ */
+async function mainMenu() {
+  ui.banner();
+  await ensureConfig();
+  await checkForUpdates();
+
+  while (true) {
+    const op = await select({
+      message: "What's the plan?",
+      options: [
+        { value: "release", label: "🚀 Release", hint: "Build, Tag, Push" },
+        { value: "build", label: "🔨 Build", hint: "Install & Build" },
+        { value: "branch", label: "🌿 Branch", hint: "Switch, Update, PR" },
+        { value: "stash", label: "📦 Stash", hint: "Save & Pop Changes" },
+        { value: "undo", label: "⏪ Rollback", hint: "Rollback Commits" },
+        { value: "sync", label: "🔄 Sync", hint: "Fetch & Pull latest" },
+        { value: "settings", label: "⚙️. Settings", hint: "Config API & Sheets" },
+        { value: "quit", label: "🚪 Quit" },
+      ],
+    });
+
+    if (isCancel(op) || op === "quit") {
+      outro("👋 Bye!");
+      process.exit(0);
+    }
+
+    try {
+      if (op === "release") await flowRelease();
+      if (op === "build") await flowBuild();
+      if (op === "branch") await flowBranch();
+      if (op === "stash") await flowStash();
+      if (op === "undo") await flowUndo();
+      if (op === "sync") await flowSync();
+      if (op === "settings") await flowSettings();
+    } catch (e) {
+      const { note } = await import("@clack/prompts");
+      note(e.message, "⚠ Unexpected Error");
+    }
+
+    console.log("");
+  }
+}
+
+/**
+ * Setup and run the CLI program
+ */
+export async function run() {
+  const program = new Command();
+  program.name("otto").description("AI-powered Release CLI").version("3.1.0");
+
+  program.command("release").action(async () => {
+    ui.banner();
+    await ensureConfig();
+    await checkForUpdates();
+    await flowRelease();
+  });
+
+  program.command("branch").action(async () => {
+    ui.banner();
+    await checkForUpdates();
+    await flowBranch();
+  });
+
+  program.command("stash").action(async () => {
+    ui.banner();
+    await checkForUpdates();
+    await flowStash();
+  });
+
+  program.command("undo").action(async () => {
+    ui.banner();
+    await checkForUpdates();
+    await flowUndo();
+  });
+
+  program.command("sync").action(async () => {
+    ui.banner();
+    await checkForUpdates();
+    await flowSync();
+  });
+
+  program.command("settings").action(async () => {
+    ui.banner();
+    await ensureConfig();
+    await checkForUpdates();
+    await flowSettings();
+  });
+
+  program.command("build").action(async () => {
+    ui.banner();
+    await checkForUpdates();
+    await flowBuild();
+  });
+
+  if (!process.argv.slice(2).length) {
+    await mainMenu();
+  } else {
+    program.parse(process.argv);
+  }
+}

package/src/services/ai.js

@@ -0,0 +1,39 @@
+import OpenAI from "openai";
+import { spinner } from "@clack/prompts";
+import pc from "picocolors";
+import { OPENAI_API_KEY } from "../config.js";
+import { ui } from "../ui/index.js";
+
+/**
+ * Generate commit message using OpenAI
+ * @param {string} diff - Git diff to analyze
+ * @returns {Promise<{msg: string, desc: string}>} Generated message and description
+ */
+export async function generateCommit(diff) {
+  if (!OPENAI_API_KEY) ui.die("Missing OPENAI_API_KEY");
+
+  const openai = new OpenAI({ apiKey: OPENAI_API_KEY });
+  const s = spinner();
+  s.start(pc.magenta("🤖 AI Analyzing changes"));
+
+  try {
+    const res = await openai.chat.completions.create({
+      model: "gpt-4o-mini",
+      messages: [
+        {
+          role: "user",
+          content:
+            `Analyze diff, return JSON with "msg" (conventional commit) and "desc" (technical summary):\n` +
+            diff.substring(0, 15000),
+        },
+      ],
+      response_format: { type: "json_object" },
+    });
+
+    s.stop(pc.green("✔ AI Analysis Complete"));
+    return JSON.parse(res.choices?.[0]?.message?.content || "{}");
+  } catch (e) {
+    s.stop(pc.red("✖ AI Failed"));
+    throw e;
+  }
+}

package/src/services/index.js

@@ -0,0 +1,2 @@
+export { logToSheet } from "./sheets.js";
+export { generateCommit } from "./ai.js";

package/src/services/sheets.js

@@ -0,0 +1,18 @@
+import { SHEET_WEBHOOK_URL } from "../config.js";
+
+/**
+ * Log data to Google Sheets via webhook
+ * @param {Object} data - Data to log
+ */
+export async function logToSheet(data) {
+  if (!SHEET_WEBHOOK_URL) return;
+  try {
+    await fetch(SHEET_WEBHOOK_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    });
+  } catch {
+    // ignore
+  }
+}