@goodtek/vibeops 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -2,8 +2,39 @@
 
 All notable changes to VibeOps are documented here.
 
+## Unreleased
+
+### Fixed
+
+- Removed dead `task-merge.ts` (local merge no longer used).
+- `task add` checks out integration branch from `origin/<branch>` when only remote exists.
+- `task done` sets Status **Done** only after push/MR succeed; skips duplicate PR when URL exists.
+- Re-init creates missing integration branch on existing repos.
+- `status` shows branch policy and MR/PR URL.
+
+## 1.1.0 - 2026-05-27
+
+### Breaking
+
+- **`task done` no longer merges locally.** It pushes the task branch and opens a **pull/merge request** to the integration branch (`gh` / `glab`). Merge and deploy happen on the host (CI).
+- **`init` requires a git remote** (`origin`) unless `--allow-no-remote` (smoke/CI).
+- **`.vibeops.json` gains a `git` block** (integration/production branches, host). Re-run `vibeops init` on older projects.
+
+### Added
+
+- **Branch policy at init:** GitFlow lite (`develop` + `main`) or trunk (`main` only); `--git-policy`, `--integration-branch`, `--production-branch`.
+- **`task add`** branches from the configured **integration** branch, not arbitrary HEAD.
+- **LLM-generated MR/PR** title and body on `task done`; URL stored in TASK **Git Context**.
+- **`--no-pr`** on `task done` to push only.
+
 ## 1.0.0 - 2026-05-27
 
+### Added
+
+- **`vibeops init --clients`**: choose **cursor**, **claude**, **codex** (≥1 required). Installs core + per-client rules/skills (`CLAUDE.md`, `.agents/skills/`, etc.).
+- **Re-init guard**: existing projects prompt before overwriting templates; `docs/tasks/TASK-*.md` are preserved. Use `--yes` for non-interactive re-init.
+- **`vibeops llm`**: `connect`, `status`, `use` for task add/done LLM providers.
+
 ### Breaking
 
 - **Four commands only:** `init`, `task add`, `task done`, `status`.

package/README.md

@@ -1,104 +1,95 @@
 # VibeOps
 
-> Minimal CLI rails for Cursor-based TASK-driven vibe coding.
+> Minimal CLI rails for TASK-driven vibe coding (Cursor, Claude Code, Codex).
 
 [![npm version](https://img.shields.io/npm/v/@goodtek/vibeops.svg)](https://www.npmjs.com/package/@goodtek/vibeops)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-VibeOps bootstraps a **Cursor-friendly repo**, starts numbered **TASK** files on Git branches, and closes them while updating **project memory** in Git. Cursor plans and implements; the CLI handles files, Git, and short LLM assists.
+VibeOps bootstraps an **agent-friendly repo**, starts numbered **TASK** files on Git branches, and closes them while updating **project memory** in Git. You plan and implement in your chosen agent; the CLI handles files, Git, and short LLM assists.
 
-## Four commands
+## Commands
 
 | Command | Purpose |
 |---------|---------|
-| `vibeops init` | Install AGENTS.md, Cursor rules/skills, docs layout, `.vibeops.json` |
-| `vibeops task add` | New `TASK-NNN` file + task branch (blocks if another TASK is In Progress) |
-| `vibeops task done` | LLM fills Result/Test + updates project docs; commit + merge |
-| `vibeops status` | Briefing: active TASK, branch, doc health, next hint |
+| `vibeops init` | Core docs + agent packs (cursor / claude / codex) |
+| `vibeops task add` | New `TASK-NNN` file + task branch |
+| `vibeops task done` | LLM summary, push branch, open MR/PR (no local merge) |
+| `vibeops status` | Briefing: TASK, Git, LLM, clients |
+| `vibeops llm` | Connect LLM providers (`connect` · `status` · `use`) |
 
-## Workflow
+## Init
 
 ```bash
-vibeops init --git --initial-commit   # once per repo
+# Interactive: pick agents (≥1), then Git
+vibeops init
 
-vibeops task add                      # interactive: idea → TASK file + branch
-# Plan in Cursor Ask:  @docs/tasks/TASK-NNN-….md
-# Build in Cursor Agent: same file + Scope / Acceptance Criteria
+# Non-interactive (GitFlow: develop + main, origin required unless CI)
+vibeops init --clients cursor,claude,codex --git --initial-commit --git-policy gitflow
 
-vibeops task done                     # close TASK, update memory, merge branch
-vibeops status                        # anytime snapshot
+# Re-init templates on an existing project
+vibeops init --clients cursor --yes
 ```
 
-If a TASK is already **In Progress**, `task add` prints a guide and exits with code 1 — it does **not** auto-run `task done`.
+| Pack | Installed |
+|------|-----------|
+| **core** (always) | `AGENTS.md`, `docs/tasks`, `docs/project`, `docs/logs` |
+| **cursor** | `.cursor/rules/`, `.cursor/skills/` |
+| **claude** | `CLAUDE.md`, `.claude/skills/` |
+| **codex** | `.agents/skills/` |
+
+Re-init **overwrites** templates (rules, skills, doc stubs). **`docs/tasks/TASK-*.md` are kept.**
 
-## What `init` creates
+## Workflow
 
-| Path | Role |
-|------|------|
-| `AGENTS.md` | Source of truth, read order, four CLI commands |
-| `.cursor/rules/` | Task source of truth, Git safety, docs on done |
-| `.cursor/skills/` | Optional `plan-task` and `implement-task` skills |
-| `docs/tasks/TASK-000-template.md` | Section template for new TASKs |
-| `docs/project/05-current-state.md` | Facts: stage, active TASK, next step |
-| `docs/project/06-decisions.md` | Append-only decision log |
-| `docs/project/03-architecture.md` | Living architecture |
-| `docs/logs/README.md` | Daily log convention |
-| `.vibeops.json` | Project metadata (no Notion) |
+```bash
+vibeops init --clients cursor --git --initial-commit
 
-## Source of truth
+vibeops task add
+# Plan / build using your agent and the current TASK file
 
-| What | Where |
-|------|--------|
-| Current work | `docs/tasks/TASK-NNN-*.md` |
-| Project memory | `docs/project/05-current-state.md`, `03-architecture.md`, `06-decisions.md` |
-| Change history | Git commits on task branches |
-| **Not** trusted | Cursor chat, Slack |
+vibeops task done
+vibeops status
+```
 
-## LLM (optional)
+If a TASK is **In Progress**, `task add` exits with a guide — it does not auto-run `task done`.
 
-Used only for **`task add`** (scaffold title/slug/sections) and **`task done`** (Result, Test Result, project doc patches).
+## LLM (optional)
 
-Providers (first match wins): Codex OAuth (`~/.codex/auth.json`), Cursor Agent CLI, `OPENAI_API_KEY` in `.vibeops.env`.
+For **`task add`** / **`task done`** only (not for coding in the IDE):
 
-Without LLM, `task add` falls back to a minimal template; `task done` uses a git-diff fallback for Result sections.
+```bash
+vibeops llm connect
+vibeops llm use auto   # auto | codex-oauth | cursor-agent | openai
+```
 
 ## Installation
 
-Node.js 20+ required.
+Node.js 20+.
 
 ```bash
 npm install -g @goodtek/vibeops
-vibeops --help
 ```
 
-Local development:
+Development:
 
 ```bash
-pnpm install
-pnpm build
-pnpm smoke          # typecheck + build + smoke cases
-node dist/cli.js --help
+pnpm install && pnpm build && pnpm smoke
 ```
 
 ## Flags (common)
 
-- **`init`**: `--dry-run`, `--cwd`, `--name`, `--git`, `--no-git`, `--initial-commit`, `--force`
-- **`task add`**: `--dry-run`, `--non-interactive --idea "…"` (CI/smoke)
-- **`task done`**: `--dry-run`, `--no-merge`, `--allow-dirty`, `--yes`, `--cwd`
-- **`status`**: `--json`, `--cwd`
-
-## Git conventions
-
-- Task branch: `task/<slug>` from current HEAD
-- Commit message: `feat(task-nnn): <short title>`
-- Merge via `task done` (confirm in TTY; `--yes` to skip prompt)
-- No force-push
-
-## Breaking change: 1.0.0
+- **`init`**: `--clients`, `--yes`, `--dry-run`, `--force`, `--git`, `--initial-commit`, `--git-policy gitflow|trunk`, `--integration-branch`, `--production-branch`, `--allow-no-remote`, `--cwd`
+- **`task add`**: `--dry-run`, `--non-interactive --idea "…"`
+- **`task done`**: `--dry-run`, `--no-pr` (push only)
+- **`status`**: `--json`
 
-v1.0 removes `plan`, `start`, `next`, `rollback`, `notion`, `github`, and legacy task subcommands. Pin `@goodtek/vibeops@0.7` if you still need them.
+## Git
 
-See [CHANGELOG.md](CHANGELOG.md) and [docs/project/v3-scope.md](docs/project/v3-scope.md).
+- **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`).
+- **`task add`**: branch `task/<slug>` from the **integration** branch (e.g. `develop`).
+- **`task done`**: commit if needed → `git push` → `gh pr create` / `glab mr create` (LLM title/body). **You merge on GitHub/GitLab**; CI deploys.
+- Commit messages: `feat(task-nnn): …`
+- No force-push to shared branches
 
 ## License
 

package/dist/bootstrap/installer.js

@@ -1,8 +1,10 @@
+import { readdir } from "node:fs/promises";
 import { join } from "node:path";
-import { ensureDir, pathExists, readText, readTextOrNull, writeText } from "../lib/filesystem.js";
+import { ensureDir, pathExists, readText, readTextOrNull, writeText, } from "../lib/filesystem.js";
+import { CLIENT_SKILL_ROOT } from "../lib/init-clients.js";
 import { dim, green, log, yellow } from "../lib/logger.js";
-import { projectPaths, VIBEOPS_ENV_FILE } from "../lib/paths.js";
-import { loadManifest, resolveDestination } from "./manifest.js";
+import { projectPaths, TEMPLATES_ROOT, VIBEOPS_ENV_FILE } from "../lib/paths.js";
+import { loadInstallManifest, resolveDestination } from "./manifest.js";
 import { applySubstitutions, buildSubstitutions, isTextPath, } from "./substitute.js";
 import { configToJson } from "../lib/config.js";
 function envExampleContents() {
@@ -74,19 +76,51 @@ async function ensureGitignoreEntry(projectRoot, dryRun) {
         relativePath: ".gitignore",
     };
 }
+async function listSharedSkillNames() {
+    const sharedRoot = join(TEMPLATES_ROOT, "skills-shared");
+    if (!(await pathExists(sharedRoot)))
+        return [];
+    const entries = await readdir(sharedRoot, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function installSharedSkills(options, subs) {
+    const outcomes = [];
+    const skillNames = await listSharedSkillNames();
+    const sharedRoot = join(TEMPLATES_ROOT, "skills-shared");
+    for (const client of options.clients) {
+        const skillRoot = CLIENT_SKILL_ROOT[client];
+        for (const skillName of skillNames) {
+            const sourceAbs = join(sharedRoot, skillName, "SKILL.md");
+            if (!(await pathExists(sourceAbs)))
+                continue;
+            const relativePath = join(skillRoot, skillName, "SKILL.md");
+            const dest = join(options.projectRoot, relativePath);
+            const entry = { relativePath, sourceAbs };
+            if (!options.dryRun) {
+                await ensureDir(join(dest, ".."));
+            }
+            outcomes.push(await copyOne(entry, dest, subs, options));
+        }
+    }
+    return outcomes;
+}
 export async function install(options) {
     const paths = projectPaths(options.projectRoot);
     const subs = buildSubstitutions(options.config);
     if (!options.dryRun) {
         await ensureDir(paths.root);
     }
-    const manifest = await loadManifest();
+    const manifest = await loadInstallManifest(options.clients);
     const outcomes = [];
     for (const entry of manifest) {
         const dest = resolveDestination(entry, paths.root);
+        if (!options.dryRun) {
+            await ensureDir(join(dest, ".."));
+        }
         const outcome = await copyOne(entry, dest, subs, options);
         outcomes.push(outcome);
     }
+    outcomes.push(...(await installSharedSkills(options, subs)));
     const configOutcome = await writeBlobIfNeeded(paths.config, ".vibeops.json", configToJson(options.config), options);
     outcomes.push(configOutcome);
     const envExampleOutcome = await writeBlobIfNeeded(paths.envExample, ".vibeops.env.example", envExampleContents(), options);

package/dist/bootstrap/manifest.js

@@ -1,6 +1,29 @@
 import { join, relative } from "node:path";
 import { walk } from "../lib/filesystem.js";
+import { pathExists } from "../lib/filesystem.js";
 import { TEMPLATES_ROOT } from "../lib/paths.js";
+async function loadManifestFromDirectory(rootDir) {
+    if (!(await pathExists(rootDir)))
+        return [];
+    const files = await walk(rootDir);
+    return files.map((abs) => ({
+        relativePath: relative(rootDir, abs),
+        sourceAbs: abs,
+    }));
+}
+/** Core tree + selected client packs (not shared skills — those are copied separately). */
+export async function loadInstallManifest(clients) {
+    const entries = [];
+    entries.push(...(await loadManifestFromDirectory(join(TEMPLATES_ROOT, "core"))));
+    for (const id of clients) {
+        entries.push(...(await loadManifestFromDirectory(join(TEMPLATES_ROOT, "clients", id))));
+    }
+    return entries.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+export function resolveDestination(entry, projectRoot) {
+    return join(projectRoot, entry.relativePath);
+}
+/** @deprecated Use loadInstallManifest — walks entire templates/ (legacy). */
 export async function loadManifest() {
     const files = await walk(TEMPLATES_ROOT);
     return files
@@ -10,6 +33,3 @@ export async function loadManifest() {
     }))
         .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
-export function resolveDestination(entry, projectRoot) {
-    return join(projectRoot, entry.relativePath);
-}

package/dist/cli.js

@@ -1,30 +1,57 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { initCommand } from "./commands/init.js";
+import { llmConnectCommand, llmStatusCommand, llmUseCommand } from "./commands/llm.js";
 import { statusCommand } from "./commands/status.js";
 import { taskAddCommand } from "./commands/task-add.js";
 import { taskDoneCommand } from "./commands/task-done.js";
+import { loadVibeopsEnv } from "./lib/env.js";
 import { VERSION } from "./version.js";
 const program = new Command();
 program
     .name("vibeops")
-    .description("VibeOps v3 — Cursor-friendly TASK workflow (init · task add · task done · status)")
+    .description("VibeOps v3 — Cursor-friendly TASK workflow (init · task · status · llm)")
     .version(VERSION, "-v, --version", "Print the VibeOps version");
+program.hook("preAction", async (_thisCommand, actionCommand) => {
+    const opts = actionCommand.opts();
+    const cwd = typeof opts.cwd === "string" ? opts.cwd : process.cwd();
+    await loadVibeopsEnv(cwd);
+});
 program
     .command("init")
-    .description("Install the VibeOps v3 project tree")
+    .description("Install core + agent client packs (cursor, claude, codex)")
     .option("--dry-run", "Show what would be created")
-    .option("--force", "Overwrite existing files")
+    .option("--force", "Overwrite existing template files (also implied when re-initializing with --yes)")
+    .option("--yes", "Re-init an existing project without prompting")
     .option("--cwd <path>", "Target directory")
     .option("--name <projectName>", "Project name in .vibeops.json")
-    .option("--git", "Initialize Git")
-    .option("--no-git", "Skip Git")
+    .option("--clients <list>", "Agent packs: comma-separated cursor, claude, codex (required in non-interactive mode)")
+    .option("--git", "Initialize Git (always on; flag kept for scripts)")
     .option("--initial-commit", "Create initial commit")
     .option("--no-initial-commit", "Skip initial commit")
-    .option("--default-branch <name>", "Default branch (default main)")
     .option("--commit-message <message>", "Initial commit message")
+    .option("--git-policy <preset>", "Branch policy: gitflow (develop+main) or trunk (main only)")
+    .option("--integration-branch <name>", "Integration branch (with --production-branch)")
+    .option("--production-branch <name>", "Production branch")
+    .option("--git-host <host>", "github or gitlab (default: detect from remote)")
+    .option("--allow-no-remote", "Smoke/CI: skip origin requirement")
     .action(async (opts) => {
-    await initCommand(opts);
+    await initCommand({
+        dryRun: Boolean(opts.dryRun),
+        force: Boolean(opts.force),
+        yes: Boolean(opts.yes),
+        cwd: opts.cwd,
+        name: opts.name,
+        clients: opts.clients,
+        git: opts.git,
+        initialCommit: opts.initialCommit,
+        commitMessage: opts.commitMessage,
+        allowNoRemote: Boolean(opts.allowNoRemote),
+        gitPolicy: opts.gitPolicy,
+        integrationBranch: opts.integrationBranch,
+        productionBranch: opts.productionBranch,
+        gitHost: opts.gitHost,
+    });
 });
 const task = program.command("task").description("TASK lifecycle");
 task
@@ -44,24 +71,20 @@ task
 });
 task
     .command("done [taskRef]")
-    .description("Close TASK: LLM summary, project memory, merge")
+    .description("Close TASK: LLM summary, push branch, open MR/PR (no local merge)")
     .option("--dry-run", "Plan only")
-    .option("--no-merge", "Skip merge")
-    .option("--allow-dirty", "Allow dirty tree during merge")
-    .option("--yes", "Merge without prompting")
+    .option("--no-pr", "Push only; skip creating MR/PR")
     .option("--cwd <path>", "Target directory")
     .action(async (taskRef, opts) => {
     await taskDoneCommand(taskRef, {
         dryRun: Boolean(opts.dryRun),
-        noMerge: Boolean(opts.noMerge),
-        allowDirty: Boolean(opts.allowDirty),
-        yes: Boolean(opts.yes),
+        noPr: Boolean(opts.noPr),
         cwd: opts.cwd,
     });
 });
 program
     .command("status")
-    .description("Briefing: active TASK, Git, next hint")
+    .description("Briefing: active TASK, Git, LLM, next hint")
     .option("--json", "JSON output")
     .option("--cwd <path>", "Target directory")
     .action(async (opts) => {
@@ -70,6 +93,32 @@ program
         cwd: opts.cwd,
     });
 });
+const llm = program.command("llm").description("LLM providers for task add / task done");
+llm
+    .command("connect")
+    .description("Interactive menu: connect providers and choose default")
+    .option("--cwd <path>", "Target directory")
+    .action(async (opts) => {
+    await llmConnectCommand({ cwd: opts.cwd });
+});
+llm
+    .command("status")
+    .description("Show connected providers and project preference")
+    .option("--json", "JSON output")
+    .option("--cwd <path>", "Target directory")
+    .action(async (opts) => {
+    await llmStatusCommand({
+        json: Boolean(opts.json),
+        cwd: opts.cwd,
+    });
+});
+llm
+    .command("use [provider]")
+    .description("Set default provider: auto | codex-oauth | cursor-agent | openai")
+    .option("--cwd <path>", "Target directory")
+    .action(async (provider, opts) => {
+    await llmUseCommand(provider, { cwd: opts.cwd });
+});
 program.parseAsync(process.argv).catch((err) => {
     console.error("[vibeops] error:", err);
     process.exitCode = 1;