@goodtek/vibeops 0.2.0

package/dist/lib/git.js

@@ -0,0 +1,237 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+async function tryGit(cwd, args) {
+    try {
+        const { stdout } = await exec("git", args, { cwd });
+        return { stdout };
+    }
+    catch {
+        return null;
+    }
+}
+export async function runGit(cwd, args) {
+    const { stdout, stderr } = await exec("git", args, { cwd });
+    return { stdout, stderr };
+}
+export async function isGitRepository(cwd) {
+    return (await tryGit(cwd, ["rev-parse", "--is-inside-work-tree"])) !== null;
+}
+export async function hasAnyCommit(cwd) {
+    return (await tryGit(cwd, ["rev-parse", "--verify", "HEAD"])) !== null;
+}
+export async function currentBranchOrUnborn(cwd) {
+    const hasCommits = await hasAnyCommit(cwd);
+    const symbolic = await tryGit(cwd, ["symbolic-ref", "--short", "HEAD"]);
+    if (symbolic !== null) {
+        const branch = symbolic.stdout.trim();
+        return {
+            branch: branch.length > 0 ? branch : null,
+            state: hasCommits ? "normal" : "unborn",
+            hasCommits,
+        };
+    }
+    const detached = await tryGit(cwd, ["rev-parse", "--short", "HEAD"]);
+    return {
+        branch: detached !== null ? detached.stdout.trim() : null,
+        state: "detached",
+        hasCommits,
+    };
+}
+export async function readGitInfo(cwd) {
+    if (!(await isGitRepository(cwd))) {
+        return { isRepo: false, branch: null, state: "none", hasCommits: null, dirty: null };
+    }
+    const branch = await currentBranchOrUnborn(cwd);
+    const statusRes = await tryGit(cwd, ["status", "--porcelain"]);
+    const dirty = statusRes ? statusRes.stdout.trim().length > 0 : null;
+    return {
+        isRepo: true,
+        branch: branch.branch,
+        state: branch.state,
+        hasCommits: branch.hasCommits,
+        dirty,
+    };
+}
+export async function gitInit(cwd) {
+    await runGit(cwd, ["init"]);
+}
+export async function gitSetDefaultBranch(cwd, branch) {
+    if (await hasAnyCommit(cwd)) {
+        await runGit(cwd, ["branch", "-M", branch]);
+        return;
+    }
+    await runGit(cwd, ["symbolic-ref", "HEAD", `refs/heads/${branch}`]);
+}
+export async function gitAddAll(cwd) {
+    await runGit(cwd, ["add", "."]);
+}
+export async function gitCommit(cwd, message) {
+    await runGit(cwd, ["commit", "-m", message]);
+}
+export async function gitHeadCommit(cwd, short = true) {
+    const res = await tryGit(cwd, short ? ["rev-parse", "--short", "HEAD"] : ["rev-parse", "HEAD"]);
+    return res ? res.stdout.trim() : null;
+}
+export async function gitBranchExists(cwd, name) {
+    const res = await tryGit(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${name}`]);
+    return res !== null;
+}
+export async function gitCreateBranch(cwd, name, startPoint) {
+    const args = ["branch", name];
+    if (typeof startPoint === "string" && startPoint.length > 0)
+        args.push(startPoint);
+    await runGit(cwd, args);
+}
+export async function gitCheckout(cwd, ref) {
+    await runGit(cwd, ["checkout", ref]);
+}
+export async function gitCheckoutNewBranch(cwd, name, startPoint) {
+    const args = ["checkout", "-b", name];
+    if (typeof startPoint === "string" && startPoint.length > 0)
+        args.push(startPoint);
+    await runGit(cwd, args);
+}
+export async function gitDeleteBranch(cwd, name, opts = {}) {
+    const flag = opts.force === true ? "-D" : "-d";
+    await runGit(cwd, ["branch", flag, name]);
+}
+export async function gitResetHard(cwd, ref) {
+    await runGit(cwd, ["reset", "--hard", ref]);
+}
+export async function gitDiffNameOnly(cwd, range) {
+    const args = ["diff", "--name-only"];
+    if (typeof range === "string" && range.length > 0)
+        args.push(range);
+    const res = await tryGit(cwd, args);
+    if (!res)
+        return [];
+    return res.stdout
+        .split("\n")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+/**
+ * Raw lines from `git status --porcelain` (read-only).
+ * Returns an empty array if the repo is unreadable.
+ */
+export async function gitStatusPorcelain(cwd) {
+    const res = await tryGit(cwd, ["status", "--porcelain"]);
+    if (!res)
+        return [];
+    return res.stdout.split("\n").filter((line) => line.length > 0);
+}
+function parsePorcelainLine(line) {
+    if (line.length < 3)
+        return null;
+    const code = line.slice(0, 2);
+    const rest = line.slice(3);
+    if (code === "??") {
+        return { code, staged: false, unstaged: false, untracked: true, path: rest };
+    }
+    if (code === "!!") {
+        return null;
+    }
+    const x = code.charAt(0);
+    const y = code.charAt(1);
+    // Rename / copy: `R  old -> new` or `C  old -> new`
+    if (x === "R" || x === "C") {
+        const arrow = rest.indexOf(" -> ");
+        if (arrow >= 0) {
+            const origPath = rest.slice(0, arrow);
+            const path = rest.slice(arrow + 4);
+            return {
+                code,
+                staged: true,
+                unstaged: y !== " " && y !== "?",
+                untracked: false,
+                path,
+                origPath,
+            };
+        }
+    }
+    return {
+        code,
+        staged: x !== " " && x !== "?",
+        unstaged: y !== " " && y !== "?",
+        untracked: false,
+        path: rest,
+    };
+}
+function parsePorcelain(lines) {
+    const out = [];
+    for (const line of lines) {
+        const entry = parsePorcelainLine(line);
+        if (entry !== null)
+            out.push(entry);
+    }
+    return out;
+}
+export async function gitWorkingTreeChangedFiles(cwd) {
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    return entries.filter((e) => e.unstaged).map((e) => e.path);
+}
+export async function gitStagedChangedFiles(cwd) {
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    return entries.filter((e) => e.staged).map((e) => e.path);
+}
+export async function gitUntrackedFiles(cwd) {
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    return entries.filter((e) => e.untracked).map((e) => e.path);
+}
+export async function gitCommittedChangedFilesSince(baseCommit, cwd) {
+    if (baseCommit.length === 0)
+        return [];
+    return gitDiffNameOnly(cwd, `${baseCommit}..HEAD`);
+}
+export async function gitAllChangedFilesSinceTaskStart(baseCommit, cwd) {
+    const entries = parsePorcelain(await gitStatusPorcelain(cwd));
+    const working = entries.filter((e) => e.unstaged).map((e) => e.path);
+    const staged = entries.filter((e) => e.staged).map((e) => e.path);
+    const untracked = entries.filter((e) => e.untracked).map((e) => e.path);
+    const committed = await gitCommittedChangedFilesSince(baseCommit, cwd);
+    const workingTree = Array.from(new Set([...working, ...staged, ...untracked]));
+    const all = Array.from(new Set([...workingTree, ...committed]));
+    return { working, staged, untracked, committed, workingTree, all };
+}
+export async function gitLogOneline(cwd, range) {
+    const args = ["log", "--oneline", "--no-decorate"];
+    if (typeof range === "string" && range.length > 0)
+        args.push(range);
+    const res = await tryGit(cwd, args);
+    if (!res)
+        return [];
+    const out = [];
+    for (const line of res.stdout.split("\n")) {
+        const m = /^([0-9a-f]+)\s+(.+)$/i.exec(line.trim());
+        if (m)
+            out.push({ sha: m[1], message: m[2] });
+    }
+    return out;
+}
+export async function gitCommitsAhead(cwd, baseRef, headRef = "HEAD") {
+    const res = await tryGit(cwd, ["rev-list", "--count", `${baseRef}..${headRef}`]);
+    if (!res)
+        return 0;
+    const n = Number.parseInt(res.stdout.trim(), 10);
+    return Number.isFinite(n) ? n : 0;
+}
+export async function detectDefaultBranch(cwd) {
+    for (const cand of ["main", "master"]) {
+        if (await gitBranchExists(cwd, cand))
+            return cand;
+    }
+    return null;
+}
+/**
+ * Read the `origin` remote URL (e.g. `git@github.com:org/repo.git`).
+ * Returns `null` if the repo has no `origin` remote or git isn't available.
+ * Read-only — never adds, sets, or fetches.
+ */
+export async function gitRemoteUrl(cwd, name = "origin") {
+    const res = await tryGit(cwd, ["remote", "get-url", name]);
+    if (!res)
+        return null;
+    const url = res.stdout.trim();
+    return url.length > 0 ? url : null;
+}

package/dist/lib/github-cli.js

@@ -0,0 +1,247 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { runGit } from "./git.js";
+const exec = promisify(execFile);
+export async function runGh(args) {
+    try {
+        const { stdout, stderr } = await exec("gh", [...args], { env: process.env });
+        return { ok: true, stdout, stderr, exitCode: 0 };
+    }
+    catch (err) {
+        const e = err;
+        return {
+            ok: false,
+            stdout: e.stdout ?? "",
+            stderr: e.stderr ?? (typeof e.message === "string" ? e.message : ""),
+            exitCode: typeof e.code === "number" ? e.code : null,
+        };
+    }
+}
+/** Returns true if `gh --version` exits 0. */
+export async function isGhInstalled() {
+    const res = await runGh(["--version"]);
+    return res.ok;
+}
+const USERNAME_RE = /Logged in to (?:github\.com|[\w.-]+) (?:as|account) ([^\s)]+)/i;
+export async function ghAuthStatus() {
+    const installed = await isGhInstalled();
+    if (!installed) {
+        return {
+            installed: false,
+            authenticated: false,
+            username: null,
+            hosts: [],
+            detail: "gh CLI not installed",
+        };
+    }
+    const res = await runGh(["auth", "status"]);
+    const text = `${res.stdout}\n${res.stderr}`;
+    const authenticated = res.ok || /Logged in to/i.test(text);
+    const userMatch = USERNAME_RE.exec(text);
+    const hosts = [];
+    for (const m of text.matchAll(/^([\w.-]+\.com)\s*$/gm)) {
+        const host = m[1]?.trim();
+        if (typeof host === "string" && host.length > 0 && !hosts.includes(host)) {
+            hosts.push(host);
+        }
+    }
+    if (hosts.length === 0 && /github\.com/i.test(text))
+        hosts.push("github.com");
+    return {
+        installed: true,
+        authenticated,
+        username: userMatch !== null ? userMatch[1].trim() : null,
+        hosts,
+        // Strip any potential token-looking strings defensively.
+        detail: maskAuthDetail(text),
+    };
+}
+function maskAuthDetail(text) {
+    return text
+        .replace(/gh[op]_[A-Za-z0-9]{20,}/g, "gh***")
+        .replace(/ghp_[A-Za-z0-9]{20,}/g, "gh***")
+        .replace(/ghu_[A-Za-z0-9]{20,}/g, "gh***")
+        .replace(/(Authorization:\s*Bearer\s+)\S+/gi, "$1***")
+        .trim();
+}
+/** Best-effort `gh api user --jq .login`. Returns `null` when gh fails. */
+export async function ghCurrentUser() {
+    const res = await runGh(["api", "user", "--jq", ".login"]);
+    if (!res.ok)
+        return null;
+    const login = res.stdout.trim();
+    return login.length > 0 ? login : null;
+}
+export async function ghRepoExists(owner, repo) {
+    if (owner.length === 0 || repo.length === 0)
+        return false;
+    const res = await runGh(["repo", "view", `${owner}/${repo}`, "--json", "name"]);
+    return res.ok;
+}
+export function buildGhCreateRepoArgs(input) {
+    const slug = `${input.owner}/${input.repo}`;
+    const args = ["repo", "create", slug];
+    args.push(input.visibility === "public" ? "--public" : "--private");
+    if (typeof input.source === "string" && input.source.length > 0) {
+        args.push(`--source=${input.source}`);
+    }
+    args.push(`--remote=${input.remote ?? "origin"}`);
+    if (typeof input.description === "string" && input.description.length > 0) {
+        args.push("--description", input.description);
+    }
+    return args;
+}
+export async function ghCreateRepo(input) {
+    const argv = buildGhCreateRepoArgs(input);
+    const command = `gh ${argv.map(shellSafe).join(" ")}`;
+    if (input.dryRun === true) {
+        return { ok: true, command, argv, dryRun: true };
+    }
+    const res = await runGh(argv);
+    return {
+        ok: res.ok,
+        command,
+        argv,
+        stdout: res.stdout,
+        stderr: res.stderr,
+        exitCode: res.exitCode,
+        dryRun: false,
+    };
+}
+/**
+ * Run `gh auth login` with the user's TTY (stdio inherit). Returns a promise
+ * resolving with the child's exit code. Caller is responsible for verifying
+ * `--dry-run` / `--yes` / non-TTY guards before invoking — this helper does
+ * NOT decide policy.
+ */
+export function ghAuthLoginInteractive() {
+    return new Promise((resolve) => {
+        const child = spawn("gh", ["auth", "login"], {
+            stdio: "inherit",
+            env: process.env,
+        });
+        child.on("exit", (code) => {
+            resolve(typeof code === "number" ? code : 1);
+        });
+        child.on("error", () => {
+            resolve(127);
+        });
+    });
+}
+const RE_SSH = /^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?$/i;
+const RE_HTTPS = /^https?:\/\/github\.com\/([^/\s?#]+)\/([^/\s?#]+?)(?:\.git)?(?:[?#].*)?$/i;
+const RE_GIT_HTTPS = /^git\+https?:\/\/github\.com\/([^/\s?#]+)\/([^/\s?#]+?)(?:\.git)?(?:[?#].*)?$/i;
+const RE_SLUG = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/;
+/** Strip a trailing `.git` and any `?...#...` suffix from a repo name. */
+function cleanRepoName(name) {
+    return name.replace(/\.git$/i, "").trim();
+}
+export function parseGitHubRemote(rawUrl) {
+    const url = rawUrl.trim();
+    const empty = {
+        isGithub: false,
+        owner: null,
+        repo: null,
+        url,
+        protocol: null,
+        httpsUrl: null,
+        gitHttpsUrl: null,
+    };
+    if (url.length === 0)
+        return empty;
+    let owner = null;
+    let repo = null;
+    let protocol = null;
+    const ssh = RE_SSH.exec(url);
+    if (ssh !== null) {
+        owner = ssh[1];
+        repo = cleanRepoName(ssh[2]);
+        protocol = "ssh";
+    }
+    else {
+        const gitHttps = RE_GIT_HTTPS.exec(url);
+        if (gitHttps !== null) {
+            owner = gitHttps[1];
+            repo = cleanRepoName(gitHttps[2]);
+            protocol = "git";
+        }
+        else {
+            const https = RE_HTTPS.exec(url);
+            if (https !== null) {
+                owner = https[1];
+                repo = cleanRepoName(https[2]);
+                protocol = "https";
+            }
+            else {
+                const slug = RE_SLUG.exec(url);
+                if (slug !== null) {
+                    owner = slug[1];
+                    repo = cleanRepoName(slug[2]);
+                    protocol = "slug";
+                }
+            }
+        }
+    }
+    if (owner === null || repo === null || repo.length === 0)
+        return empty;
+    const httpsUrl = `https://github.com/${owner}/${repo}`;
+    const gitHttpsUrl = `git+https://github.com/${owner}/${repo}.git`;
+    return {
+        isGithub: true,
+        owner,
+        repo,
+        url,
+        protocol,
+        httpsUrl,
+        gitHttpsUrl,
+    };
+}
+export async function gitRemoteList(cwd) {
+    try {
+        const { stdout } = await exec("git", ["remote", "-v"], { cwd });
+        const out = [];
+        const seen = new Set();
+        for (const line of stdout.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0)
+                continue;
+            const m = /^([^\s]+)\s+([^\s]+)\s+\((fetch|push)\)$/.exec(trimmed);
+            if (m === null)
+                continue;
+            const name = m[1];
+            const url = m[2];
+            const key = `${name}\t${url}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ name, url });
+        }
+        // Deduplicate to one entry per remote name (prefer fetch).
+        const byName = new Map();
+        for (const e of out) {
+            if (!byName.has(e.name))
+                byName.set(e.name, e);
+        }
+        return Array.from(byName.values());
+    }
+    catch {
+        return [];
+    }
+}
+/** Add a new git remote. Throws if remote already exists or git fails. */
+export async function gitRemoteAdd(cwd, name, url) {
+    await runGit(cwd, ["remote", "add", name, url]);
+}
+/** Update an existing git remote URL. Throws if remote does not exist. */
+export async function gitRemoteSetUrl(cwd, name, url) {
+    await runGit(cwd, ["remote", "set-url", name, url]);
+}
+/**
+ * Quote a single argv element for human-readable command preview. Not used
+ * to actually execute commands — we always go through execFile arg arrays.
+ */
+function shellSafe(s) {
+    if (/^[\w@/:.+=-]+$/.test(s))
+        return s;
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}

package/dist/lib/inquirer-helpers.js

@@ -0,0 +1,111 @@
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+export const OTHER_LABEL = "Other";
+function isOther(value) {
+    return value === OTHER_LABEL;
+}
+function formatCustom(text) {
+    return `Other: ${text.trim()}`;
+}
+export async function askInput(opts) {
+    if (opts.nonInteractive) {
+        const value = opts.default ?? opts.fallback ?? "";
+        return value.trim();
+    }
+    const answer = await input({
+        message: opts.message,
+        default: opts.default,
+        validate: (raw) => {
+            if (opts.required && raw.trim().length === 0) {
+                return "This field is required.";
+            }
+            return true;
+        },
+    });
+    return answer.trim();
+}
+export async function askSelect(opts) {
+    if (opts.nonInteractive) {
+        const fallback = opts.default ?? opts.choices[0] ?? "";
+        return fallback;
+    }
+    const choices = opts.choices.map((c) => ({ name: c, value: c }));
+    const answer = await select({
+        message: opts.message,
+        choices,
+        default: opts.default ?? opts.choices[0],
+        loop: false,
+        pageSize: 8,
+    });
+    if (!isOther(answer))
+        return answer;
+    const custom = await input({
+        message: `↳ ${opts.message} — enter the value for "Other" (leave empty to keep "Other")`,
+    });
+    return custom.trim().length > 0 ? formatCustom(custom) : OTHER_LABEL;
+}
+export async function askCheckbox(opts) {
+    if (opts.nonInteractive) {
+        return [...(opts.default ?? [])];
+    }
+    const defaults = new Set(opts.default ?? []);
+    const choices = opts.choices.map((c) => ({ name: c, value: c, checked: defaults.has(c) }));
+    const answer = await checkbox({
+        message: `${opts.message}  ${"\u001b[2m"}(arrow keys · Space · Enter)${"\u001b[0m"}`,
+        choices,
+        loop: false,
+        pageSize: 8,
+    });
+    const out = [];
+    for (const item of answer) {
+        if (!isOther(item)) {
+            out.push(item);
+            continue;
+        }
+        const custom = await input({
+            message: `↳ ${opts.message} — enter values for "Other" (comma-separated, leave empty to keep "Other")`,
+        });
+        const trimmed = custom.trim();
+        if (trimmed.length === 0) {
+            out.push(OTHER_LABEL);
+            continue;
+        }
+        for (const piece of trimmed.split(",")) {
+            const t = piece.trim();
+            if (t.length > 0)
+                out.push(formatCustom(t));
+        }
+    }
+    return out;
+}
+export async function askConfirm(opts) {
+    if (opts.nonInteractive)
+        return opts.default;
+    return await confirm({ message: opts.message, default: opts.default });
+}
+/**
+ * Yes/No question rendered as a 2-choice `select` prompt instead of a
+ * `confirm` prompt. This means the user navigates with ←/→ or ↑/↓ and
+ * presses Enter — they never have to type `y` or `n`.
+ *
+ * Returns a boolean (`true` = Yes, `false` = No).
+ */
+export async function yesNoSelect(opts) {
+    return await select({
+        message: opts.message,
+        choices: [
+            { name: "Yes", value: true },
+            { name: "No", value: false },
+        ],
+        default: opts.defaultValue ?? true,
+        loop: false,
+        pageSize: 2,
+    });
+}
+/**
+ * Wrapper around `yesNoSelect` that respects a non-interactive flag (CI).
+ */
+export async function askYesNo(opts) {
+    if (opts.nonInteractive)
+        return opts.defaultValue ?? true;
+    return yesNoSelect({ message: opts.message, defaultValue: opts.defaultValue ?? true });
+}

package/dist/lib/logger.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-console */
+const useColor = () => {
+    if (process.env["NO_COLOR"])
+        return false;
+    if (process.env["FORCE_COLOR"])
+        return true;
+    return process.stdout.isTTY === true;
+};
+const color = (code, s) => (useColor() ? `\x1b[${code}m${s}\x1b[0m` : s);
+export const dim = (s) => color("2", s);
+export const bold = (s) => color("1", s);
+export const green = (s) => color("32", s);
+export const yellow = (s) => color("33", s);
+export const red = (s) => color("31", s);
+export const cyan = (s) => color("36", s);
+export const gray = (s) => color("90", s);
+export const log = {
+    info(msg) {
+        console.log(msg);
+    },
+    step(msg) {
+        console.log(`${cyan("→")} ${msg}`);
+    },
+    ok(msg) {
+        console.log(`${green("✓")} ${msg}`);
+    },
+    skip(msg) {
+        console.log(`${dim("·")} ${dim(msg)}`);
+    },
+    warn(msg) {
+        console.warn(`${yellow("!")} ${msg}`);
+    },
+    error(msg) {
+        console.error(`${red("✗")} ${msg}`);
+    },
+    raw(msg) {
+        process.stdout.write(msg);
+    },
+    blank() {
+        console.log("");
+    },
+};