@goodtek/vibeops 1.0.0 → 1.1.1

package/dist/commands/status.js

@@ -1,7 +1,9 @@
 import { resolve } from "node:path";
-import { readConfig } from "../lib/config.js";
+import { readConfig, getClientsFromConfig } from "../lib/config.js";
+import { formatGitPolicySummary } from "../lib/git-policy.js";
 import { readText } from "../lib/filesystem.js";
 import { readGitInfo } from "../lib/git.js";
+import { buildLlmStatusReport } from "../lib/llm-status.js";
 import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
 import { VERSION } from "../version.js";
@@ -29,6 +31,7 @@ async function buildReport(cwd) {
     let taskBranch = null;
     let branchExists = null;
     let goalExcerpt = "";
+    let mergeRequestUrl = null;
     if (focus !== null) {
         const body = await readText(focus.filePath);
         goalExcerpt = summarizeGoal(body);
@@ -36,6 +39,7 @@ async function buildReport(cwd) {
         testFilled = hasNonEmptySection(body, "Test Result");
         const ctx = await readGitContext(focus.filePath);
         taskBranch = ctx?.taskBranch ?? null;
+        mergeRequestUrl = ctx?.mergeRequestUrl ?? null;
         onTaskBranch = isOnTaskBranch(git.branch, ctx);
         branchExists = await taskBranchExistsFor(cwd, focus);
         focusBlock = {
@@ -49,6 +53,7 @@ async function buildReport(cwd) {
             onTaskBranch,
             taskBranch,
             taskBranchExists: branchExists,
+            mergeRequestUrl,
         };
     }
     const hint = computeNextHint({
@@ -58,14 +63,17 @@ async function buildReport(cwd) {
         testFilled,
         onTaskBranch,
     });
+    const llm = isVibeopsProject ? await buildLlmStatusReport(cwd) : null;
     return {
         vibeopsVersion: VERSION,
         isVibeopsProject,
         projectName: config?.name ?? null,
+        clients: getClientsFromConfig(config),
         git: {
             isRepo: git.isRepo,
             branch: git.branch,
             dirty: git.dirty,
+            policy: config?.git ? formatGitPolicySummary(config.git) : null,
         },
         counts,
         inProgress: inProgress.map((t) => ({
@@ -75,6 +83,7 @@ async function buildReport(cwd) {
         })),
         focus: focusBlock,
         nextHint: hintToText(hint, cwd, focus),
+        llm,
     };
 }
 function printHuman(report) {
@@ -90,6 +99,9 @@ function printHuman(report) {
         return;
     }
     log.info(`  ${dim("Project")}  ${report.projectName ?? "(unnamed)"}`);
+    if (report.clients.length > 0) {
+        log.info(`  ${dim("Clients")}  ${report.clients.join(", ")}`);
+    }
     if (report.counts) {
         const c = report.counts;
         log.info(`  ${dim("Tasks")}    ${c.total} total · ${cyan(String(c.in_progress))} in progress · ${c.done} done`);
@@ -125,6 +137,9 @@ function printHuman(report) {
             log.info(`    ${dim("Tree")}    ${yellow("dirty")}`);
         else if (report.git.dirty === false)
             log.info(`    ${dim("Tree")}    ${green("clean")}`);
+        if (report.git.policy) {
+            log.info(`    ${dim("Policy")}   ${report.git.policy}`);
+        }
         if (report.focus?.taskBranch) {
             const on = report.focus.onTaskBranch === true
                 ? green("yes")
@@ -133,6 +148,27 @@ function printHuman(report) {
                     : dim("—");
             log.info(`    ${dim("Task br.")}  ${report.focus.taskBranch} · on branch: ${on}`);
         }
+        if (report.focus?.mergeRequestUrl) {
+            log.info(`    ${dim("MR/PR")}    ${report.focus.mergeRequestUrl}`);
+        }
+    }
+    if (report.llm) {
+        log.blank();
+        log.info(bold("  LLM"));
+        log.info(`    ${dim("Preferred")}  ${report.llm.preference}`);
+        const active = report.llm.active !== null
+            ? green(`${report.llm.active} (ok)`)
+            : report.llm.anyAvailable
+                ? yellow("(preference not available)")
+                : yellow("none");
+        log.info(`    ${dim("Active")}     ${active}`);
+        for (const p of report.llm.providers) {
+            const summary = p.summary.length > 56 ? `${p.summary.slice(0, 53)}…` : p.summary;
+            log.info(`    ${dim(p.id.padEnd(14))} ${p.ok ? green("ok") : dim("—")}  ${dim(summary)}`);
+        }
+        if (!report.llm.anyAvailable) {
+            log.info(`    ${dim("Setup")}     ${cyan("vibeops llm connect")}`);
+        }
     }
     log.blank();
     log.info(`${dim("Next")}     ${report.nextHint}`);

package/dist/commands/task-add.js

@@ -1,21 +1,39 @@
 import { resolve } from "node:path";
 import { pathExists, writeText } from "../lib/filesystem.js";
+import { GitConfigError, requireGitConfig } from "../lib/git-config.js";
 import { askInput } from "../lib/inquirer-helpers.js";
 import { bold, cyan, dim, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
-import { readConfig } from "../lib/config.js";
 import { slugify } from "../lib/slug.js";
 import { fallbackTaskDraft, llmScaffoldTask } from "../lib/task-add-llm.js";
 import { allocateNextTaskNumber, formatTaskId, uniqueTaskPath, } from "../lib/task-scaffold.js";
 import { findBlockingTask, relPath } from "../lib/task-context.js";
 import { startTaskBranch } from "../lib/task-start.js";
 import { loadActionableTasks, readGitContext } from "../lib/task.js";
+async function loadGitConfigOrNull(root, dryRun) {
+    try {
+        return await requireGitConfig(root);
+    }
+    catch (e) {
+        if (e instanceof GitConfigError) {
+            if (dryRun)
+                return null;
+            log.error(e.message);
+            process.exitCode = 1;
+            return null;
+        }
+        throw e;
+    }
+}
 export async function taskAddCommand(opts = {}) {
     const root = resolve(opts.cwd ?? process.cwd());
     const dryRun = opts.dryRun === true;
     const nonInteractive = opts.nonInteractive === true || dryRun || process.stdin.isTTY !== true;
     log.info(bold("vibeops task add"));
     log.blank();
+    const gitCfg = await loadGitConfigOrNull(root, dryRun);
+    if (!dryRun && gitCfg === null)
+        return;
     const paths = projectPaths(root);
     const blocking = await findBlockingTask(paths, root);
     if (blocking !== null) {
@@ -59,6 +77,7 @@ export async function taskAddCommand(opts = {}) {
         }
         else {
             log.warn("LLM unavailable — using minimal TASK template.");
+            log.info(dim(`  Run ${cyan("vibeops llm connect")} to set up Codex, Cursor Agent CLI, or OpenAI.`));
             const fb = fallbackTaskDraft(taskId, idea);
             title = fb.title;
             slug = fb.slug;
@@ -67,9 +86,19 @@ export async function taskAddCommand(opts = {}) {
     }
     const { filePath } = uniqueTaskPath(paths.docsTasks, taskId, slugify(slug || title), tasks.map((t) => t.filePath));
     const relFile = relPath(root, filePath);
+    const integration = gitCfg?.integrationBranch ?? "integration";
     if (dryRun) {
         log.info(`[dry-run] Would create ${bold(taskId)} → ${cyan(relFile)}`);
-        log.info(dim(`  branch task/${slugify(slug || title).replace(/^(\d+)-/, "$1-")}`));
+        log.info(dim(`  branch task/${slugify(slug || title).replace(/^(\d+)-/, "$1-")} from ${integration}`));
+        if (gitCfg) {
+            await startTaskBranch({
+                cwd: root,
+                taskFile: filePath,
+                integrationBranch: gitCfg.integrationBranch,
+                remote: gitCfg.remote,
+                dryRun: true,
+            });
+        }
         return;
     }
     if (await pathExists(filePath)) {
@@ -77,15 +106,13 @@ export async function taskAddCommand(opts = {}) {
     }
     await writeText(filePath, markdown);
     log.ok(`Created ${bold(taskId)} → ${cyan(relFile)}`);
-    const config = await readConfig(root);
-    if (config === null) {
-        log.warn("No .vibeops.json — run vibeops init for full template.");
-    }
     log.blank();
     log.step("Starting task branch…");
     const started = await startTaskBranch({
         cwd: root,
         taskFile: filePath,
+        integrationBranch: gitCfg.integrationBranch,
+        remote: gitCfg.remote,
         allowDirty: true,
     });
     if (!started) {

package/dist/commands/task-done.js

@@ -1,14 +1,13 @@
 import { resolve } from "node:path";
-import { askYesNo } from "../lib/inquirer-helpers.js";
 import { readText } from "../lib/filesystem.js";
 import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
 import { projectPaths } from "../lib/paths.js";
 import { resolveTask, taskNotFoundMessage } from "../lib/resolve-task.js";
-import { mergeTaskBranch } from "../lib/task-merge.js";
 import { applyTaskDoneMemory, fallbackResultSections, llmCompleteTaskDone, writeTaskResultSections, } from "../lib/task-done-llm.js";
 import { relPath } from "../lib/task-context.js";
 import { gitAddPaths, listWorkingTreeRelPaths, partitionPathsForAutoCommit, readGitInfo, runGit, } from "../lib/git.js";
 import { hasNonEmptySection, markGitContextDone, parseTaskFilename, readGitContext, readTaskFile, updateInlineStatus, } from "../lib/task.js";
+import { finishTaskWithPullRequest } from "../lib/task-push-pr.js";
 function commitMessageFor(taskId, title) {
     const slug = title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim() || taskId;
     return `feat(${taskId.toLowerCase()}): ${slug}`;
@@ -36,7 +35,6 @@ export async function taskDoneCommand(taskRef, options = {}) {
     const cwd = resolve(options.cwd ?? process.cwd());
     const paths = projectPaths(cwd);
     const dryRun = options.dryRun === true;
-    const interactive = !dryRun && process.stdin.isTTY === true && options.yes !== true;
     const resolved = await resolveTask(paths, cwd, taskRef);
     if (resolved === null) {
         log.error(taskNotFoundMessage(taskRef));
@@ -98,44 +96,42 @@ export async function taskDoneCommand(taskRef, options = {}) {
         if (!resultOk || !testOk) {
             log.info("  · LLM fill Result / Test Result + patch docs/project/*");
         }
-        log.info("  · Status → Done");
-        log.info("  · commit if dirty, merge task branch (unless --no-merge)");
+        log.info("  · commit if dirty, push task branch, open MR/PR (unless --no-pr)");
+        log.info("  · Status → Done after push/MR succeed");
+        await finishTaskWithPullRequest({
+            cwd,
+            taskFile,
+            dryRun: true,
+            skipPr: options.noPr === true,
+        });
         return;
     }
-    await updateInlineStatus(taskFile, "done");
-    await markGitContextDone(taskFile);
-    log.ok("Status → Done");
     const parts = parseTaskFilename(taskFile);
     const commitMsg = commitMessageFor(parts.id, meta.title);
     await tryCommitDirty(cwd, commitMsg, false);
     const gitCtx = await readGitContext(taskFile);
-    if (options.noMerge !== true && gitCtx !== null) {
-        let doMerge = options.yes === true || !interactive;
-        if (interactive) {
-            doMerge = await askYesNo({
-                message: `Merge into ${gitCtx.baseBranch} and delete ${gitCtx.taskBranch}?`,
-                nonInteractive: false,
-                defaultValue: true,
-            });
-        }
-        if (doMerge) {
-            const mergeResult = await mergeTaskBranch({
-                cwd,
-                taskId: meta.id,
-                taskTitle: meta.title,
-                gitCtx,
-                allowDirty: options.allowDirty,
-            });
-            if (!mergeResult.ok)
-                process.exitCode = 1;
+    if (gitCtx !== null) {
+        const prResult = await finishTaskWithPullRequest({
+            cwd,
+            taskFile,
+            skipPr: options.noPr === true,
+        });
+        if (!prResult.ok) {
+            log.error("TASK left In Progress — fix push/MR, then rerun task done.");
+            process.exitCode = 1;
+            return;
         }
-        else {
-            log.info(dim("Merge skipped."));
+        if (prResult.mergeRequestUrl) {
+            log.info(`  ${dim("MR/PR")}     ${prResult.mergeRequestUrl}`);
+            log.info(dim("Merge on GitHub/GitLab — CI deploys after merge."));
         }
     }
-    else if (gitCtx === null) {
-        log.info(dim("No Git Context — merge skipped."));
+    else {
+        log.info(dim("No Git Context — push/MR skipped."));
     }
+    await updateInlineStatus(taskFile, "done");
+    await markGitContextDone(taskFile);
+    log.ok("Status → Done");
     log.blank();
     log.info(`Next: ${cyan("vibeops task add")} or ${cyan("vibeops status")}`);
 }

package/dist/lib/config.js

@@ -1,8 +1,57 @@
 import { join } from "node:path";
-import { readTextOrNull, writeText } from "./filesystem.js";
+import { pathExists, readTextOrNull, writeText } from "./filesystem.js";
 import { VIBEOPS_CONFIG_FILE } from "./paths.js";
 import { VERSION } from "../version.js";
-import { VIBEOPS_CONFIG_SCHEMA_VERSION } from "../types/config.js";
+import { VIBEOPS_CONFIG_SCHEMA_VERSION, } from "../types/config.js";
+import { isVibeopsClientId } from "./init-clients.js";
+function parseClientsBlock(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = [];
+    for (const item of raw) {
+        if (typeof item === "string" && isVibeopsClientId(item) && !out.includes(item)) {
+            out.push(item);
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+export function getClientsFromConfig(config) {
+    if (config?.clients && config.clients.length > 0)
+        return [...config.clients];
+    return ["cursor"];
+}
+export async function isVibeopsProject(root) {
+    if ((await readConfig(root)) !== null)
+        return true;
+    return pathExists(join(root, VIBEOPS_CONFIG_FILE));
+}
+function parseGitBlock(raw) {
+    if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    const o = raw;
+    const remote = typeof o.remote === "string" && o.remote.length > 0 ? o.remote : "origin";
+    const host = o.host === "github" || o.host === "gitlab" ? o.host : undefined;
+    const integrationBranch = typeof o.integrationBranch === "string" && o.integrationBranch.length > 0
+        ? o.integrationBranch
+        : undefined;
+    const productionBranch = typeof o.productionBranch === "string" && o.productionBranch.length > 0
+        ? o.productionBranch
+        : undefined;
+    if (!host || !integrationBranch || !productionBranch)
+        return undefined;
+    return { remote, host, integrationBranch, productionBranch };
+}
+function parseLlmBlock(raw) {
+    if (raw === null || raw === undefined || typeof raw !== "object" || Array.isArray(raw)) {
+        return undefined;
+    }
+    const p = raw.provider;
+    if (p === "auto" || p === "codex-oauth" || p === "cursor-agent" || p === "openai") {
+        return { provider: p };
+    }
+    return undefined;
+}
 export async function readConfig(root) {
     const text = await readTextOrNull(join(root, VIBEOPS_CONFIG_FILE));
     if (text === null)
@@ -13,11 +62,17 @@ export async function readConfig(root) {
             typeof parsed.vibeopsVersion === "string" &&
             typeof parsed.createdAt === "string" &&
             parsed.schemaVersion === VIBEOPS_CONFIG_SCHEMA_VERSION) {
+            const llm = parseLlmBlock(parsed.llm);
+            const git = parseGitBlock(parsed.git);
+            const clients = parseClientsBlock(parsed.clients) ?? ["cursor"];
             return {
                 name: parsed.name,
                 vibeopsVersion: parsed.vibeopsVersion,
                 schemaVersion: VIBEOPS_CONFIG_SCHEMA_VERSION,
                 createdAt: parsed.createdAt,
+                clients,
+                ...(git ? { git } : {}),
+                ...(llm ? { llm } : {}),
             };
         }
         return null;
@@ -26,12 +81,15 @@ export async function readConfig(root) {
         return null;
     }
 }
-export function buildConfig(name, nowIso) {
+export function buildConfig(name, clients, git, existing, nowIso) {
     return {
         name,
         vibeopsVersion: VERSION,
         schemaVersion: VIBEOPS_CONFIG_SCHEMA_VERSION,
-        createdAt: nowIso ?? new Date().toISOString(),
+        createdAt: existing?.createdAt ?? nowIso ?? new Date().toISOString(),
+        clients,
+        git,
+        llm: existing?.llm ?? { provider: "auto" },
     };
 }
 export function configToJson(config) {
@@ -40,3 +98,25 @@ export function configToJson(config) {
 export async function writeConfig(root, config) {
     await writeText(join(root, VIBEOPS_CONFIG_FILE), configToJson(config));
 }
+/**
+ * Merge `llm.provider` into existing `.vibeops.json` (preserves other keys).
+ */
+export async function setLlmProviderPreference(root, provider) {
+    const path = join(root, VIBEOPS_CONFIG_FILE);
+    const text = await readTextOrNull(path);
+    if (text === null) {
+        throw new Error(`${VIBEOPS_CONFIG_FILE} not found — run vibeops init first.`);
+    }
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${VIBEOPS_CONFIG_FILE} is not valid JSON.`);
+    }
+    const prevLlm = typeof data.llm === "object" && data.llm !== null && !Array.isArray(data.llm)
+        ? data.llm
+        : {};
+    data.llm = { ...prevLlm, provider };
+    await writeText(path, `${JSON.stringify(data, null, 2)}\n`);
+}

package/dist/lib/env.js

@@ -0,0 +1,32 @@
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { VIBEOPS_ENV_FILE } from "./paths.js";
+/**
+ * Loads `KEY=value` pairs from `.vibeops.env` without overwriting existing `process.env`.
+ */
+export async function loadVibeopsEnv(cwd) {
+    const path = join(resolve(cwd), VIBEOPS_ENV_FILE);
+    try {
+        const text = await readFile(path, "utf-8");
+        for (const line of text.split("\n")) {
+            const t = line.trim();
+            if (t.length === 0 || t.startsWith("#"))
+                continue;
+            const eq = t.indexOf("=");
+            if (eq <= 0)
+                continue;
+            const key = t.slice(0, eq).trim();
+            let val = t.slice(eq + 1).trim();
+            if ((val.startsWith('"') && val.endsWith('"')) ||
+                (val.startsWith("'") && val.endsWith("'"))) {
+                val = val.slice(1, -1);
+            }
+            if (key.length > 0 && process.env[key] === undefined) {
+                process.env[key] = val;
+            }
+        }
+    }
+    catch {
+        /* missing or unreadable — ok */
+    }
+}

package/dist/lib/git-config.js

@@ -0,0 +1,21 @@
+import { readConfig } from "./config.js";
+export class GitConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitConfigError";
+    }
+}
+/** Load `.vibeops.json` git block or throw with re-init guidance. */
+export async function requireGitConfig(cwd) {
+    const config = await readConfig(cwd);
+    if (!config) {
+        throw new GitConfigError("No .vibeops.json found. Run vibeops init in this project first.");
+    }
+    if (!config.git?.integrationBranch || !config.git?.productionBranch) {
+        throw new GitConfigError("Missing git policy in .vibeops.json. Re-run vibeops init to set integration and production branches.");
+    }
+    if (!config.git.host || !config.git.remote) {
+        throw new GitConfigError("Incomplete git config in .vibeops.json. Re-run vibeops init.");
+    }
+    return config.git;
+}

package/dist/lib/git-host.js

@@ -0,0 +1,12 @@
+/** Infer Git host from a remote URL. */
+export function detectGitHost(remoteUrl) {
+    const u = remoteUrl.trim().toLowerCase();
+    if (u.includes("github.com"))
+        return "github";
+    if (u.includes("gitlab"))
+        return "gitlab";
+    return null;
+}
+export function mergeRequestLabel(host) {
+    return host === "gitlab" ? "Merge request" : "Pull request";
+}

package/dist/lib/git-policy.js

@@ -0,0 +1,67 @@
+import { select } from "@inquirer/prompts";
+import { askInput } from "./inquirer-helpers.js";
+export const GIT_POLICY_PRESETS = [
+    {
+        id: "gitflow",
+        label: "GitFlow lite — develop (integration) + main (production)",
+        integrationBranch: "develop",
+        productionBranch: "main",
+    },
+    {
+        id: "trunk",
+        label: "Trunk — main only (integration and production = main)",
+        integrationBranch: "main",
+        productionBranch: "main",
+    },
+];
+export function parseGitPolicyArg(raw) {
+    if (raw === undefined || raw.trim().length === 0)
+        return null;
+    const t = raw.trim().toLowerCase();
+    if (t === "gitflow" || t === "develop-main")
+        return "gitflow";
+    if (t === "trunk" || t === "main")
+        return "trunk";
+    if (t === "custom")
+        return "custom";
+    return null;
+}
+export function resolvePreset(id) {
+    return GIT_POLICY_PRESETS.find((p) => p.id === id) ?? null;
+}
+export async function askGitPolicy() {
+    const preset = await select({
+        message: "Branch policy",
+        choices: [
+            ...GIT_POLICY_PRESETS.map((p) => ({ name: p.label, value: p.id })),
+            { name: "Custom branch names", value: "custom" },
+        ],
+        loop: false,
+    });
+    if (preset !== "custom") {
+        const p = resolvePreset(preset);
+        return {
+            integrationBranch: p.integrationBranch,
+            productionBranch: p.productionBranch,
+        };
+    }
+    const integrationBranch = await askInput({
+        message: "Integration branch (task branches start here; MR/PR target)",
+        nonInteractive: false,
+        default: "develop",
+        required: true,
+    });
+    const productionBranch = await askInput({
+        message: "Production branch (releases / deploy; merge manually)",
+        nonInteractive: false,
+        default: "main",
+        required: true,
+    });
+    return { integrationBranch, productionBranch };
+}
+export function formatGitPolicySummary(git) {
+    if (git.integrationBranch === git.productionBranch) {
+        return `${git.integrationBranch} (integration + production)`;
+    }
+    return `integration=${git.integrationBranch}, production=${git.productionBranch}`;
+}

package/dist/lib/git-remote.js

@@ -0,0 +1,108 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { askInput } from "./inquirer-helpers.js";
+import { detectGitHost } from "./git-host.js";
+import { gitRemoteUrl, runGit } from "./git.js";
+import { dim, log } from "./logger.js";
+const execFileAsync = promisify(execFile);
+async function probeGh() {
+    try {
+        await execFileAsync("gh", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function probeGlab() {
+    try {
+        await execFileAsync("glab", ["auth", "status"], { maxBuffer: 1024 * 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function createGithubRepo(cwd, name) {
+    const { stdout } = await execFileAsync("gh", 
+    // gh requires an explicit visibility flag when non-interactive.
+    ["repo", "create", name, "--source=.", "--remote=origin", "--push", "--private"], { cwd, maxBuffer: 8 * 1024 * 1024 });
+    const match = stdout.match(/https:\/\/github\.com\/[^\s]+/);
+    if (match)
+        return match[0].replace(/\.git$/, "") + ".git";
+    const url = await gitRemoteUrl(cwd, "origin");
+    if (url)
+        return url;
+    throw new Error("gh repo create finished but origin URL could not be read.");
+}
+async function createGitlabRepo(cwd, name, defaultBranch) {
+    await execFileAsync("glab", ["repo", "create", name, "--remote=origin", "--defaultBranch", defaultBranch], { cwd, maxBuffer: 8 * 1024 * 1024 });
+    const url = await gitRemoteUrl(cwd, "origin");
+    if (url)
+        return url;
+    throw new Error("glab repo create finished but origin URL could not be read.");
+}
+/**
+ * Ensures `origin` (or named remote) exists. Interactive path can create via gh/glab or manual URL.
+ */
+export async function ensureOriginRemote(opts) {
+    const remote = opts.remoteName ?? "origin";
+    const existing = await gitRemoteUrl(opts.cwd, remote);
+    if (existing) {
+        const host = detectGitHost(existing);
+        if (!host) {
+            log.warn(`Remote ${remote} URL is not GitHub or GitLab: ${existing}`);
+            if (opts.allowMissing)
+                return null;
+            throw new Error("Only GitHub and GitLab remotes are supported.");
+        }
+        return { remote, url: existing, host };
+    }
+    if (opts.dryRun) {
+        log.info(dim(`would configure git remote ${remote}`));
+        return { remote, url: "(dry-run)", host: "github" };
+    }
+    if (opts.allowMissing) {
+        return null;
+    }
+    if (opts.nonInteractive) {
+        throw new Error(`Git remote "${remote}" is not configured. Add it with: git remote add ${remote} <url>`);
+    }
+    log.blank();
+    log.info("Remote origin is required for push and merge requests.");
+    const ghOk = await probeGh();
+    const glabOk = await probeGlab();
+    if (ghOk) {
+        const name = await askInput({
+            message: "GitHub repository name (owner/repo or name for gh to create)",
+            nonInteractive: false,
+            required: true,
+        });
+        log.info(dim("Creating GitHub repository via gh…"));
+        const url = await createGithubRepo(opts.cwd, name);
+        return { remote, url, host: "github" };
+    }
+    if (glabOk) {
+        const name = await askInput({
+            message: "GitLab project path (group/project)",
+            nonInteractive: false,
+            required: true,
+        });
+        log.info(dim("Creating GitLab project via glab…"));
+        const defaultBranch = typeof opts.defaultBranch === "string" && opts.defaultBranch.length > 0
+            ? opts.defaultBranch
+            : "main";
+        const url = await createGitlabRepo(opts.cwd, name, defaultBranch);
+        return { remote, url, host: "gitlab" };
+    }
+    const url = await askInput({
+        message: `Remote URL for ${remote} (https://github.com/… or https://gitlab.com/…)`,
+        nonInteractive: false,
+        required: true,
+    });
+    await runGit(opts.cwd, ["remote", "add", remote, url.trim()]);
+    const host = detectGitHost(url);
+    if (!host)
+        throw new Error("Only GitHub and GitLab HTTPS/SSH URLs are supported.");
+    return { remote, url: url.trim(), host };
+}