@goodtek/vibeops 1.0.0 → 1.1.2

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 };
+}

package/dist/lib/git.js

@@ -83,6 +83,36 @@ export async function gitBranchExists(cwd, name) {
     const res = await tryGit(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${name}`]);
     return res !== null;
 }
+export async function gitRemoteBranchExists(cwd, remote, branch) {
+    const res = await tryGit(cwd, [
+        "show-ref",
+        "--verify",
+        "--quiet",
+        `refs/remotes/${remote}/${branch}`,
+    ]);
+    return res !== null;
+}
+/**
+ * Checkout local `branch`, creating it from `remote/branch` when only the remote ref exists.
+ */
+export async function gitSwitchToBranch(cwd, branch, remote = "origin") {
+    if (await gitBranchExists(cwd, branch)) {
+        await gitCheckout(cwd, branch);
+        return true;
+    }
+    if ((await gitRemoteUrl(cwd, remote)) === null)
+        return false;
+    try {
+        await gitFetch(cwd, remote, branch);
+    }
+    catch {
+        // branch may not exist on remote yet
+    }
+    if (!(await gitRemoteBranchExists(cwd, remote, branch)))
+        return false;
+    await gitCheckoutNewBranch(cwd, branch, `${remote}/${branch}`);
+    return true;
+}
 export async function gitCreateBranch(cwd, name, startPoint) {
     const args = ["branch", name];
     if (typeof startPoint === "string" && startPoint.length > 0)
@@ -459,3 +489,16 @@ export async function gitRemoteUrl(cwd, name = "origin") {
     const url = res.stdout.trim();
     return url.length > 0 ? url : null;
 }
+export async function gitFetch(cwd, remote, ref) {
+    const args = ["fetch", remote];
+    if (typeof ref === "string" && ref.length > 0)
+        args.push(ref);
+    await runGit(cwd, args);
+}
+export async function gitPullFastForwardOnly(cwd, remote, branch) {
+    await runGit(cwd, ["pull", "--ff-only", remote, branch]);
+}
+export async function gitPush(cwd, remote, branch, setUpstream = true) {
+    const args = setUpstream ? ["push", "-u", remote, branch] : ["push", remote, branch];
+    await runGit(cwd, args);
+}

package/dist/lib/init-clients.js

@@ -0,0 +1,55 @@
+import { checkbox } from "@inquirer/prompts";
+export const VIBEOPS_CLIENT_IDS = ["cursor", "claude", "codex"];
+export const CLIENT_LABELS = {
+    cursor: "Cursor (.cursor/rules, .cursor/skills)",
+    claude: "Claude Code (CLAUDE.md, .claude/skills)",
+    codex: "Codex CLI (.agents/skills)",
+};
+/** Relative skill root per client (under project root). */
+export const CLIENT_SKILL_ROOT = {
+    cursor: ".cursor/skills",
+    claude: ".claude/skills",
+    codex: ".agents/skills",
+};
+export function parseClientsArg(raw) {
+    if (raw === undefined || raw.trim().length === 0)
+        return null;
+    const parts = raw.split(",").map((p) => p.trim().toLowerCase());
+    const out = [];
+    for (const p of parts) {
+        const id = parseOneClient(p);
+        if (id === null)
+            return null;
+        if (!out.includes(id))
+            out.push(id);
+    }
+    return out.length > 0 ? out : null;
+}
+function parseOneClient(token) {
+    if (token === "cursor")
+        return "cursor";
+    if (token === "claude" || token === "claude-code" || token === "claudecode")
+        return "claude";
+    if (token === "codex" || token === "codex-cli")
+        return "codex";
+    return null;
+}
+export function isVibeopsClientId(value) {
+    return VIBEOPS_CLIENT_IDS.includes(value);
+}
+export async function askInitClients() {
+    const selected = await checkbox({
+        message: "Which coding agents will you use? (Space toggle · Enter confirm)",
+        choices: VIBEOPS_CLIENT_IDS.map((id) => ({
+            name: CLIENT_LABELS[id],
+            value: id,
+            checked: id === "cursor",
+        })),
+        loop: false,
+        validate: (answer) => answer.length > 0 ? true : "Select at least one agent (Cursor, Claude Code, and/or Codex).",
+    });
+    return selected;
+}
+export function formatClientsList(clients) {
+    return clients.map((c) => CLIENT_LABELS[c]).join(", ");
+}

package/dist/lib/llm-complete.js

@@ -1,30 +1,20 @@
-import { probeCodexOAuthFile } from "./plan-codex-auth.js";
+import { resolveAvailableLlmProvider, resolveLlmProviderForUse } from "./llm-preference.js";
 import { codexOAuthTextCompletion } from "./plan-codex-responses.js";
 import { cursorAgentPrint, extractAgentAssistantText } from "./plan-llm-cursor-agent.js";
-import { probeCursorAgentCli, probeOpenAiApiKey } from "./plan-llm-detect.js";
 import { extractJsonObject, openAiChatCompletionJson, openAiChatCompletionText, } from "./plan-llm-openai.js";
-/** Non-interactive: Codex OAuth → Cursor Agent → OpenAI API key (same sources as `vibeops plan`). */
-export async function resolveAvailableLlmProvider(cwd) {
-    const codex = await probeCodexOAuthFile();
-    if (codex.ok)
-        return "codex-oauth";
-    const cursor = await probeCursorAgentCli(cwd);
-    if (cursor.ok)
-        return "cursor-agent";
-    const openai = await probeOpenAiApiKey();
-    if (openai.ok)
-        return "openai";
-    return null;
-}
 function formatMessagesForCursor(messages) {
     return messages
         .map((m) => `### ${m.role}\n\n${m.content}`)
         .join("\n\n---\n\n");
 }
 export async function llmCompleteText(messages, opts) {
-    const provider = opts.provider ?? (await resolveAvailableLlmProvider(opts.cwd));
+    const pref = opts.preference ?? "auto";
+    const provider = opts.provider ?? (await resolveLlmProviderForUse(opts.cwd, pref));
     if (provider === null) {
-        throw new Error("No LLM provider available. Use Codex OAuth (~/.codex/auth.json), Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
+        if (pref !== "auto") {
+            throw new Error(`Preferred LLM "${pref}" is not available (not installed or not authenticated). Run \`vibeops llm connect\` or \`vibeops llm use auto\`.`);
+        }
+        throw new Error("No LLM provider available. Run `vibeops llm connect` or set Codex OAuth, Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
     }
     if (provider === "openai") {
         const text = await openAiChatCompletionText({ messages, model: opts.model });
@@ -42,9 +32,13 @@ export async function llmCompleteText(messages, opts) {
     return { text: extractAgentAssistantText(raw), provider: "cursor-agent" };
 }
 export async function llmCompleteJson(messages, opts) {
-    const provider = opts.provider ?? (await resolveAvailableLlmProvider(opts.cwd));
+    const pref = opts.preference ?? "auto";
+    const provider = opts.provider ?? (await resolveLlmProviderForUse(opts.cwd, pref));
     if (provider === null) {
-        throw new Error("No LLM provider available. Use Codex OAuth (~/.codex/auth.json), Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
+        if (pref !== "auto") {
+            throw new Error(`Preferred LLM "${pref}" is not available (not installed or not authenticated). Run \`vibeops llm connect\` or \`vibeops llm use auto\`.`);
+        }
+        throw new Error("No LLM provider available. Run `vibeops llm connect` or set Codex OAuth, Cursor Agent CLI (`agent login`), or OPENAI_API_KEY.");
     }
     if (provider === "openai") {
         const text = await openAiChatCompletionJson({ messages, model: opts.model });
@@ -60,3 +54,8 @@ export async function llmCompleteJson(messages, opts) {
     const { text: raw } = await llmCompleteText(jsonMessages, { ...opts, provider });
     return { text: extractJsonObject(raw), provider };
 }
+export { resolveAvailableLlmProvider } from "./llm-preference.js";
+/** True if any provider can run completions (ignores project preference). */
+export async function anyLlmProviderAvailable(cwd) {
+    return (await resolveAvailableLlmProvider(cwd)) !== null;
+}

package/dist/lib/llm-connect.js

@@ -0,0 +1,150 @@
+import { spawn } from "node:child_process";
+import { access, appendFile, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { dim, log } from "./logger.js";
+import { codexAuthJsonPath, probeCodexOAuthFile } from "./plan-codex-auth.js";
+import { probeCursorAgentCli, probeOpenAiApiKey } from "./plan-llm-detect.js";
+import { VIBEOPS_ENV_FILE } from "./paths.js";
+function agentBin() {
+    return process.env.VIBEOPS_CURSOR_AGENT_BIN?.trim() || "agent";
+}
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runCursorAgentLogin(cwd) {
+    const command = agentBin();
+    const before = await probeCursorAgentCli(cwd);
+    if (before.reason?.includes("not found on PATH")) {
+        return {
+            ok: false,
+            message: [
+                `Command "${command}" is not on PATH.`,
+                "Install Cursor Agent CLI: https://cursor.com/docs/cli",
+                "Then rerun: vibeops llm connect",
+            ].join("\n"),
+        };
+    }
+    log.info(`Running ${command} login — complete auth in the browser if prompted.`);
+    log.blank();
+    return await new Promise((resolve) => {
+        const child = spawn(command, ["login"], {
+            cwd,
+            stdio: "inherit",
+            env: process.env,
+            shell: process.platform === "win32",
+        });
+        child.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                resolve({
+                    ok: false,
+                    message: `Command "${command}" not found. Install from https://cursor.com/docs/cli`,
+                });
+                return;
+            }
+            resolve({ ok: false, message: err.message });
+        });
+        child.on("close", async (code) => {
+            const after = await probeCursorAgentCli(cwd);
+            if (after.ok) {
+                resolve({ ok: true, message: "Cursor Agent CLI is authenticated." });
+                return;
+            }
+            if (code === 0) {
+                resolve({
+                    ok: false,
+                    message: after.reason ?? "Login finished but `agent status` still reports not authenticated.",
+                });
+                return;
+            }
+            resolve({
+                ok: false,
+                message: after.reason ?? `${command} login exited with code ${code ?? "unknown"}.`,
+            });
+        });
+    });
+}
+export async function guideCodexOAuth() {
+    const path = codexAuthJsonPath();
+    const probe = await probeCodexOAuthFile();
+    if (probe.ok) {
+        return { ok: true, message: `Codex OAuth already configured at ${path}` };
+    }
+    return {
+        ok: false,
+        message: [
+            "Codex OAuth is not configured yet.",
+            "",
+            "Option A — official Codex CLI:",
+            "  codex login",
+            "",
+            "Option B — copy auth from another machine:",
+            `  Place auth.json at ${path}`,
+            "",
+            "Then rerun: vibeops llm connect",
+        ].join("\n"),
+    };
+}
+export async function configureOpenAiKey(projectRoot, apiKey) {
+    const trimmed = apiKey.trim();
+    const envPath = join(projectRoot, VIBEOPS_ENV_FILE);
+    if (trimmed.length === 0) {
+        return { ok: false, message: "API key cannot be empty.", envPath };
+    }
+    const line = `OPENAI_API_KEY=${trimmed}`;
+    if (await fileExists(envPath)) {
+        const existing = await readFile(envPath, "utf-8");
+        if (/^OPENAI_API_KEY=/m.test(existing)) {
+            const next = existing.replace(/^OPENAI_API_KEY=.*$/m, line);
+            await writeFile(envPath, next.endsWith("\n") ? next : `${next}\n`, "utf-8");
+        }
+        else {
+            await appendFile(envPath, existing.endsWith("\n") ? `${line}\n` : `\n${line}\n`, "utf-8");
+        }
+    }
+    else {
+        await writeFile(envPath, ["# VibeOps · optional environment (gitignored)", "# Never commit secrets.", "", line, ""].join("\n"), "utf-8");
+    }
+    process.env.OPENAI_API_KEY = trimmed;
+    const verify = await probeOpenAiApiKey();
+    if (!verify.ok) {
+        return {
+            ok: false,
+            message: verify.reason ?? "Key saved but OpenAI verification failed.",
+            envPath,
+        };
+    }
+    return {
+        ok: true,
+        message: `OpenAI API key saved to ${VIBEOPS_ENV_FILE} and verified.`,
+        envPath,
+    };
+}
+export function codexAuthHint() {
+    return codexAuthJsonPath();
+}
+export function cursorAgentHint() {
+    return agentBin();
+}
+export function openAiEnvHint(projectRoot) {
+    return join(projectRoot, VIBEOPS_ENV_FILE);
+}
+export function printConnectSetupHint(provider) {
+    switch (provider) {
+        case "cursor-agent":
+            log.info(dim("  https://cursor.com/docs/cli"));
+            log.info(dim("  Then: agent login  (or vibeops llm connect → Set up Cursor Agent CLI)"));
+            break;
+        case "codex-oauth":
+            log.info(dim(`  codex login  → ${codexAuthHint()}`));
+            break;
+        case "openai":
+            log.info(dim(`  vibeops llm connect → Set up OpenAI API key  (writes ${VIBEOPS_ENV_FILE})`));
+            break;
+    }
+}

package/dist/lib/llm-preference.js

@@ -0,0 +1,102 @@
+import { relative } from "node:path";
+import { probeCodexOAuthFile } from "./plan-codex-auth.js";
+import { probeCursorAgentCli, probeOpenAiApiKey } from "./plan-llm-detect.js";
+export const LLM_PROVIDER_ORDER = [
+    "codex-oauth",
+    "cursor-agent",
+    "openai",
+];
+function shortPath(cwd, abs) {
+    const r = relative(cwd, abs);
+    return r.startsWith("..") || r.length === 0 ? abs : r;
+}
+/**
+ * First available provider in Codex → Cursor Agent → OpenAI order.
+ */
+export async function resolveAvailableLlmProvider(cwd) {
+    const codex = await probeCodexOAuthFile();
+    if (codex.ok)
+        return "codex-oauth";
+    const cursor = await probeCursorAgentCli(cwd);
+    if (cursor.ok)
+        return "cursor-agent";
+    const openai = await probeOpenAiApiKey();
+    if (openai.ok)
+        return "openai";
+    return null;
+}
+export async function probeAllLlmProviders(cwd) {
+    const codex = await probeCodexOAuthFile();
+    const cursor = await probeCursorAgentCli(cwd);
+    const openai = await probeOpenAiApiKey();
+    return [
+        {
+            id: "codex-oauth",
+            ok: codex.ok,
+            summary: codex.ok ? `ok · ${shortPath(cwd, codex.path)}` : (codex.reason ?? "not configured"),
+        },
+        {
+            id: "cursor-agent",
+            ok: cursor.ok,
+            summary: cursor.ok ? `ok · command: ${cursor.command}` : (cursor.reason ?? "not configured"),
+        },
+        {
+            id: "openai",
+            ok: openai.ok,
+            summary: openai.ok ? "ok · OPENAI_API_KEY" : (openai.reason ?? "not configured"),
+        },
+    ];
+}
+export function parseLlmProviderPreference(raw) {
+    const t = raw.trim().toLowerCase();
+    if (t === "auto")
+        return "auto";
+    if (t === "codex-oauth" || t === "codex")
+        return "codex-oauth";
+    if (t === "cursor-agent" || t === "cursor")
+        return "cursor-agent";
+    if (t === "openai")
+        return "openai";
+    return null;
+}
+export function labelLlmProvider(id) {
+    switch (id) {
+        case "auto":
+            return "Auto (Codex → Cursor → OpenAI)";
+        case "codex-oauth":
+            return "Codex OAuth (~/.codex/auth.json)";
+        case "cursor-agent":
+            return "Cursor Agent CLI (`agent`)";
+        case "openai":
+            return "OpenAI API (OPENAI_API_KEY)";
+        default:
+            return id;
+    }
+}
+/**
+ * Resolves which concrete provider to use given project preference.
+ * - `auto` / undefined: same as `resolveAvailableLlmProvider`.
+ * - explicit: that provider only if its probe passes.
+ */
+export async function resolveLlmProviderForUse(cwd, preference) {
+    const pref = preference ?? "auto";
+    if (pref === "auto") {
+        return resolveAvailableLlmProvider(cwd);
+    }
+    if (pref === "codex-oauth") {
+        const c = await probeCodexOAuthFile();
+        return c.ok ? "codex-oauth" : null;
+    }
+    if (pref === "cursor-agent") {
+        const c = await probeCursorAgentCli(cwd);
+        return c.ok ? "cursor-agent" : null;
+    }
+    const o = await probeOpenAiApiKey();
+    return o.ok ? "openai" : null;
+}
+export function getLlmPreferenceFromConfig(config) {
+    const p = config?.llm?.provider;
+    if (p === "auto" || p === "codex-oauth" || p === "cursor-agent" || p === "openai")
+        return p;
+    return "auto";
+}

package/dist/lib/llm-status.js

@@ -0,0 +1,19 @@
+import { readConfig } from "./config.js";
+import { getLlmPreferenceFromConfig, labelLlmProvider, probeAllLlmProviders, resolveLlmProviderForUse, } from "./llm-preference.js";
+export async function buildLlmStatusReport(cwd) {
+    const config = await readConfig(cwd);
+    const preference = getLlmPreferenceFromConfig(config);
+    const providers = await probeAllLlmProviders(cwd);
+    const active = await resolveLlmProviderForUse(cwd, preference);
+    const anyAvailable = providers.some((p) => p.ok);
+    return { preference, active, providers, anyAvailable };
+}
+export function formatLlmStatusLine(report) {
+    const preferenceLabel = labelLlmProvider(report.preference);
+    const activeLabel = report.active !== null
+        ? `${labelLlmProvider(report.active)} (ok)`
+        : report.anyAvailable
+            ? "none (preference blocked or misconfigured)"
+            : "none — run vibeops llm connect";
+    return { preferenceLabel, activeLabel };
+}

package/dist/lib/pr-create.js

@@ -0,0 +1,66 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mergeRequestLabel } from "./git-host.js";
+import { log } from "./logger.js";
+const execFileAsync = promisify(execFile);
+async function ghPrCreate(opts) {
+    const { stdout } = await execFileAsync("gh", [
+        "pr",
+        "create",
+        "--base",
+        opts.baseBranch,
+        "--head",
+        opts.headBranch,
+        "--title",
+        opts.title,
+        "--body",
+        opts.body,
+    ], { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
+    const line = stdout.trim().split("\n").pop()?.trim();
+    if (line && line.startsWith("http"))
+        return line;
+    throw new Error("gh pr create did not return a URL.");
+}
+async function glabMrCreate(opts) {
+    const { stdout } = await execFileAsync("glab", [
+        "mr",
+        "create",
+        "--target-branch",
+        opts.baseBranch,
+        "--source-branch",
+        opts.headBranch,
+        "--title",
+        opts.title,
+        "--description",
+        opts.body,
+    ], { cwd: opts.cwd, maxBuffer: 4 * 1024 * 1024 });
+    const line = stdout.trim().split("\n").pop()?.trim();
+    if (line && (line.startsWith("http") || line.includes("merge_requests")))
+        return line;
+    const match = stdout.match(/https?:\/\/[^\s]+/);
+    if (match)
+        return match[0];
+    throw new Error("glab mr create did not return a URL.");
+}
+export async function createMergeRequest(opts) {
+    const label = mergeRequestLabel(opts.host);
+    if (opts.dryRun) {
+        log.info(`would create ${label}: ${opts.headBranch} → ${opts.baseBranch}`);
+        return { url: `(dry-run ${label})` };
+    }
+    const url = opts.host === "gitlab" ? await glabMrCreate(opts) : await ghPrCreate(opts);
+    return { url };
+}
+export async function probeMergeRequestCli(host) {
+    try {
+        if (host === "gitlab") {
+            await execFileAsync("glab", ["--version"], { maxBuffer: 1024 });
+            return true;
+        }
+        await execFileAsync("gh", ["--version"], { maxBuffer: 1024 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/task-add-llm.js

@@ -1,6 +1,8 @@
 import { join, relative } from "node:path";
 import { readTextOrNull } from "./filesystem.js";
+import { readConfig } from "./config.js";
 import { llmCompleteJson } from "./llm-complete.js";
+import { getLlmPreferenceFromConfig } from "./llm-preference.js";
 import { projectPaths } from "./paths.js";
 import { slugify } from "./slug.js";
 import { buildMinimalTaskMarkdown, ensureV3Sections, normalizeTaskHeader, titleFromIdea, } from "./task-scaffold.js";
@@ -53,7 +55,12 @@ export async function llmScaffoldTask(params) {
                 content: [`TASK id: ${params.taskId}`, `Idea: ${params.idea}`, "", context].join("\n"),
             },
         ];
-        const { text: raw, provider } = await llmCompleteJson(messages, { cwd: params.cwd });
+        const config = await readConfig(params.cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text: raw, provider } = await llmCompleteJson(messages, {
+            cwd: params.cwd,
+            preference,
+        });
         const parsed = JSON.parse(extractJsonObject(raw));
         const title = typeof parsed.title === "string"
             ? parsed.title.replace(/^TASK-\d+\s*[:\-]\s*/i, "").trim()

package/dist/lib/task-done-llm.js

@@ -1,6 +1,8 @@
 import { join } from "node:path";
 import { readText, readTextOrNull, writeText } from "./filesystem.js";
+import { readConfig } from "./config.js";
 import { llmCompleteJson } from "./llm-complete.js";
+import { getLlmPreferenceFromConfig } from "./llm-preference.js";
 import { gitDiffNameOnly, readGitInfo } from "./git.js";
 import { projectPaths, PROJECT_MEMORY_FILES } from "./paths.js";
 import { extractJsonObject } from "./plan-llm-openai.js";
@@ -64,7 +66,12 @@ Be factual. Do not invent files not in the diff.`,
         },
     ];
     try {
-        const { text: raw, provider } = await llmCompleteJson(messages, { cwd: params.cwd });
+        const config = await readConfig(params.cwd);
+        const preference = getLlmPreferenceFromConfig(config);
+        const { text: raw, provider } = await llmCompleteJson(messages, {
+            cwd: params.cwd,
+            preference,
+        });
         const parsed = JSON.parse(extractJsonObject(raw));
         const result = typeof parsed.result === "string" ? parsed.result.trim() : "";
         const testResult = typeof parsed.testResult === "string" ? parsed.testResult.trim() : "";