@goodtek/vibeops 0.2.0

package/dist/commands/github-status.js

@@ -0,0 +1,164 @@
+import { resolve } from "node:path";
+import { readConfig } from "../lib/config.js";
+import { ghAuthStatus, gitRemoteList, isGhInstalled, parseGitHubRemote, } from "../lib/github-cli.js";
+import { readBugsUrl, readHomepage, readPackageJson, readRepositoryUrl, } from "../lib/package-json.js";
+import { bold, cyan, dim, green, log, yellow } from "../lib/logger.js";
+async function collect(cwd) {
+    const [installed, auth, remotes, vibeopsConfig, pkg] = await Promise.all([
+        isGhInstalled(),
+        ghAuthStatus(),
+        gitRemoteList(cwd),
+        readConfig(cwd),
+        readPackageJson(cwd),
+    ]);
+    const origin = remotes.find((r) => r.name === "origin") ?? null;
+    const otherGithub = remotes.find((r) => r.name !== "origin" && parseGitHubRemote(r.url).isGithub);
+    const chosen = origin ?? otherGithub ?? null;
+    const remote = chosen
+        ? {
+            name: chosen.name,
+            url: chosen.url,
+            info: parseGitHubRemote(chosen.url),
+        }
+        : null;
+    return {
+        cwd,
+        gh: {
+            installed,
+            authenticated: auth.authenticated,
+            username: auth.username,
+            hosts: auth.hosts,
+        },
+        remote,
+        config: vibeopsConfig?.github
+            ? {
+                enabled: vibeopsConfig.github.enabled,
+                mode: vibeopsConfig.github.mode,
+                owner: vibeopsConfig.github.owner,
+                repo: vibeopsConfig.github.repo,
+                remote: vibeopsConfig.github.remote,
+                visibility: vibeopsConfig.github.visibility,
+                url: vibeopsConfig.github.url,
+            }
+            : null,
+        package: pkg
+            ? {
+                present: true,
+                repositoryUrl: readRepositoryUrl(pkg.data),
+                homepage: readHomepage(pkg.data),
+                bugsUrl: readBugsUrl(pkg.data),
+            }
+            : { present: false, repositoryUrl: "", homepage: "", bugsUrl: "" },
+    };
+}
+function fmtRow(label, value, accent = "info") {
+    const padded = label.padEnd(20, " ");
+    const decorated = accent === "ok"
+        ? green(value)
+        : accent === "warn"
+            ? yellow(value)
+            : accent === "off"
+                ? dim(value)
+                : value;
+    log.info(`  ${padded} ${decorated}`);
+}
+function describeRemote(report) {
+    if (report.remote === null)
+        return { text: "none", accent: "off" };
+    const { info } = report.remote;
+    if (info.isGithub && info.owner !== null && info.repo !== null) {
+        return {
+            text: `${report.remote.name} ${info.owner}/${info.repo}  ${dim(info.url)}`,
+            accent: "ok",
+        };
+    }
+    return {
+        text: `${report.remote.name} ${report.remote.url}  ${yellow("(not a GitHub URL)")}`,
+        accent: "warn",
+    };
+}
+function describePackage(report) {
+    if (!report.package.present)
+        return { text: "none", accent: "off" };
+    const url = report.package.repositoryUrl;
+    if (url.length === 0)
+        return { text: "none", accent: "off" };
+    const info = parseGitHubRemote(url);
+    if (info.isGithub && info.owner !== null && info.repo !== null) {
+        return {
+            text: `${info.owner}/${info.repo}  ${dim(url)}`,
+            accent: "ok",
+        };
+    }
+    return { text: `${url}  ${yellow("(not a GitHub URL)")}`, accent: "warn" };
+}
+function describeConfig(report) {
+    if (report.config === null)
+        return { text: "no  (no github section)", accent: "off" };
+    if (!report.config.enabled)
+        return {
+            text: `no  (config present, enabled=false)`,
+            accent: "off",
+        };
+    const slug = report.config.owner.length > 0 && report.config.repo.length > 0
+        ? `${report.config.owner}/${report.config.repo}`
+        : "(owner/repo missing)";
+    const visibility = report.config.visibility.length > 0 ? report.config.visibility : "?";
+    return {
+        text: `yes  ${slug}  visibility=${visibility}  remote=${report.config.remote}`,
+        accent: report.config.owner.length > 0 && report.config.repo.length > 0 ? "ok" : "warn",
+    };
+}
+function printHuman(report) {
+    log.info(bold("GitHub"));
+    fmtRow("gh installed", report.gh.installed ? "yes" : "no", report.gh.installed ? "ok" : "off");
+    if (report.gh.installed) {
+        fmtRow("gh authenticated", report.gh.authenticated
+            ? `yes${report.gh.username !== null ? `  ${dim(`as ${report.gh.username}`)}` : ""}`
+            : "no", report.gh.authenticated ? "ok" : "off");
+    }
+    else {
+        fmtRow("gh authenticated", "n/a", "off");
+    }
+    const remote = describeRemote(report);
+    fmtRow("git remote origin", remote.text, remote.accent);
+    const cfg = describeConfig(report);
+    fmtRow("config enabled", cfg.text, cfg.accent);
+    const pkg = describePackage(report);
+    fmtRow("package repo", pkg.text, pkg.accent);
+    log.blank();
+    if (!report.gh.installed) {
+        log.info(`${yellow("!")} gh CLI not found. Install via ${cyan("brew install gh")} (macOS) and re-run.`);
+    }
+    else if (!report.gh.authenticated) {
+        log.info(`${yellow("!")} gh installed but not authenticated. Run ${cyan("gh auth login")} first.`);
+    }
+    else if (report.remote === null) {
+        log.info(`${dim("·")} No git remote yet. Run ${cyan("vibeops github init")} to create or connect one.`);
+    }
+    else if (!report.remote.info.isGithub) {
+        log.info(`${yellow("!")} ${report.remote.name} is not a GitHub URL. Reconnect with ${cyan("vibeops github init --connect <owner/repo>")}.`);
+    }
+    else if (report.config === null || !report.config.enabled) {
+        log.info(`${dim("·")} Remote OK, but .vibeops.json has no github section. Run ${cyan("vibeops github init")} to record it.`);
+    }
+    else if (report.package.present &&
+        parseGitHubRemote(report.package.repositoryUrl).isGithub === false) {
+        log.info(`${dim("·")} package.json repository fields are not GitHub URLs. Re-run ${cyan("vibeops github init")} to update them.`);
+    }
+    else {
+        log.ok("GitHub setup looks consistent.");
+    }
+}
+export async function githubStatusCommand(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const report = await collect(cwd);
+    if (options.json === true) {
+        log.raw(`${JSON.stringify(report, null, 2)}\n`);
+        return;
+    }
+    printHuman(report);
+    // Non-blocking: github status never sets a non-zero exit code by itself.
+    // The user is informed; nothing about gh missing / unauthenticated should
+    // break CI scripts that only call `vibeops github status` to probe state.
+}

package/dist/commands/init.js

@@ -0,0 +1,179 @@
+import { basename, resolve } from "node:path";
+import { install, printReport } from "../bootstrap/installer.js";
+import { buildConfig } from "../lib/config.js";
+import { currentBranchOrUnborn, gitAddAll, gitCommit, gitInit, gitSetDefaultBranch, gitStatusPorcelain, hasAnyCommit, isGitRepository, } from "../lib/git.js";
+import { askInput, askYesNo } from "../lib/inquirer-helpers.js";
+import { cyan, dim, green, log, yellow } from "../lib/logger.js";
+const DEFAULT_BRANCH = "main";
+const DEFAULT_COMMIT_MESSAGE = "chore: initialize vibeops project";
+function deriveProjectName(root, explicit) {
+    if (explicit && explicit.trim().length > 0)
+        return explicit.trim();
+    const base = basename(root);
+    if (base.length > 0 && base !== "/")
+        return base;
+    return "untitled-project";
+}
+export async function initCommand(options = {}) {
+    const dryRun = options.dryRun === true;
+    const force = options.force === true;
+    const projectRoot = resolve(options.cwd ?? process.cwd());
+    const interactive = !dryRun && process.stdin.isTTY === true && options.git === undefined;
+    const name = deriveProjectName(projectRoot, options.name);
+    const config = buildConfig(name);
+    log.step(`vibeops init ${dryRun ? "(dry-run) " : ""}→ ${projectRoot}`);
+    log.info(`  project: ${name}`);
+    log.info(`  vibeops: ${config.vibeopsVersion}`);
+    if (force)
+        log.warn("--force is on — existing files will be overwritten.");
+    log.blank();
+    const report = await install({ projectRoot, config, dryRun, force });
+    printReport(report, dryRun);
+    const gitPlan = await resolveGitPlan(options, interactive);
+    await runGitSetup(projectRoot, gitPlan, dryRun);
+    if (!dryRun) {
+        log.blank();
+        log.info("Next steps:");
+        log.info("  1. Open AGENTS.md and confirm the project name.");
+        log.info("  2. Run `vibeops status` to verify installation.");
+        log.info("  3. Run `vibeops plan` to populate docs/project/* (or fill them by hand).");
+    }
+}
+async function resolveGitPlan(options, interactive) {
+    const defaultBranch = typeof options.defaultBranch === "string" && options.defaultBranch.trim().length > 0
+        ? options.defaultBranch.trim()
+        : DEFAULT_BRANCH;
+    const commitMessage = typeof options.commitMessage === "string" && options.commitMessage.trim().length > 0
+        ? options.commitMessage.trim()
+        : DEFAULT_COMMIT_MESSAGE;
+    if (interactive) {
+        log.blank();
+        log.info("Git setup");
+        const shouldInitGit = await askYesNo({
+            message: "Initialize Git repository?",
+            nonInteractive: false,
+            defaultValue: true,
+        });
+        if (!shouldInitGit) {
+            return {
+                shouldInitGit: false,
+                shouldSetDefaultBranch: false,
+                defaultBranch,
+                shouldInitialCommit: false,
+                commitMessage,
+            };
+        }
+        const useMain = await askYesNo({
+            message: "Use `main` as default branch?",
+            nonInteractive: false,
+            defaultValue: true,
+        });
+        const shouldInitialCommit = await askYesNo({
+            message: "Create initial commit?",
+            nonInteractive: false,
+            defaultValue: true,
+        });
+        const finalMessage = shouldInitialCommit
+            ? await askInput({
+                message: "Initial commit message",
+                nonInteractive: false,
+                default: commitMessage,
+                required: true,
+            })
+            : commitMessage;
+        return {
+            shouldInitGit: true,
+            shouldSetDefaultBranch: useMain,
+            defaultBranch,
+            shouldInitialCommit,
+            commitMessage: finalMessage.length > 0 ? finalMessage : commitMessage,
+        };
+    }
+    const shouldInitGit = options.git !== false && (options.git === true || options.initialCommit === true);
+    if (!shouldInitGit) {
+        return {
+            shouldInitGit: false,
+            shouldSetDefaultBranch: false,
+            defaultBranch,
+            shouldInitialCommit: false,
+            commitMessage,
+        };
+    }
+    return {
+        shouldInitGit: true,
+        shouldSetDefaultBranch: true,
+        defaultBranch,
+        shouldInitialCommit: options.initialCommit !== false,
+        commitMessage,
+    };
+}
+async function runGitSetup(projectRoot, plan, dryRun) {
+    log.blank();
+    log.info("Git setup:");
+    if (!plan.shouldInitGit) {
+        log.info(`  ${dim("skipped")} Git initialization`);
+        if (dryRun) {
+            log.info(`  ${dim("hint")} use ${cyan("vibeops init --git --initial-commit")} to include Git setup in non-interactive mode`);
+        }
+        return;
+    }
+    const alreadyRepo = await isGitRepository(projectRoot);
+    const hasCommitsBefore = alreadyRepo ? await hasAnyCommit(projectRoot) : false;
+    if (dryRun) {
+        log.info(`  ${alreadyRepo ? dim("would skip") : green("would run")} git init`);
+        if (plan.shouldSetDefaultBranch) {
+            log.info(`  ${green("would set")} default branch ${cyan(plan.defaultBranch)}`);
+        }
+        if (plan.shouldInitialCommit) {
+            log.info(`  ${green("would run")} git add .`);
+            log.info(`  ${green("would run")} git commit -m ${JSON.stringify(plan.commitMessage)}`);
+        }
+        else {
+            log.info(`  ${dim("would skip")} initial commit`);
+        }
+        log.info(`  ${dim("dry-run")} no git commands executed`);
+        return;
+    }
+    if (alreadyRepo) {
+        log.info(`  ${dim("skipped")} git init (already a git repository)`);
+    }
+    else {
+        await gitInit(projectRoot);
+        log.ok("git init");
+    }
+    if (plan.shouldSetDefaultBranch) {
+        const hasCommitsNow = await hasAnyCommit(projectRoot);
+        if (alreadyRepo && hasCommitsNow) {
+            log.info(`  ${yellow("skipped")} default branch change (repository already has commits)`);
+        }
+        else {
+            await gitSetDefaultBranch(projectRoot, plan.defaultBranch);
+            log.ok(`default branch ${plan.defaultBranch}`);
+        }
+    }
+    if (!plan.shouldInitialCommit) {
+        log.info(`  ${dim("skipped")} initial commit`);
+        return;
+    }
+    if (hasCommitsBefore || (await hasAnyCommit(projectRoot))) {
+        log.info(`  ${yellow("skipped")} initial commit (repository already has commits)`);
+        return;
+    }
+    const changedFiles = await gitStatusPorcelain(projectRoot);
+    log.info(`  ${dim("initial commit files")} ${changedFiles.length} file${changedFiles.length === 1 ? "" : "s"} will be included`);
+    if (changedFiles.length === 0) {
+        log.info(`  ${dim("skipped")} initial commit (nothing to commit)`);
+        return;
+    }
+    try {
+        await gitAddAll(projectRoot);
+        await gitCommit(projectRoot, plan.commitMessage);
+        const branch = await currentBranchOrUnborn(projectRoot);
+        log.ok(`initial commit created${branch.branch !== null ? ` on ${branch.branch}` : ""}`);
+    }
+    catch (err) {
+        log.error(`initial commit failed: ${err.message}`);
+        log.info(`  ${dim("hint")} check Git user.name/user.email, then run ${cyan(`git commit -m ${JSON.stringify(plan.commitMessage)}`)} manually.`);
+        process.exitCode = 1;
+    }
+}