kritya 0.8.49-beta → 0.8.51-beta

package/README.md

@@ -175,6 +175,9 @@ In-session commands (type `/` to see them with autocomplete; letters filter the
 | `/diff`                   | show the cumulative git diff of this session's changes                                                                              |
 | `/init`                   | scan the repo and generate a `KRITYA.md` project-memory file                                                                        |
 | `/commit`                 | have the agent review, stage, and commit the current git changes                                                                    |
+| `/pr`                     | push the branch and open a GitHub PR: `/pr [--draft] [--title T] [--body B] [--base BR]`                                            |
+| `/summarize`              | one-shot summary of the session so far (history is left untouched)                                                                  |
+| `/template`               | prompt templates: list, /template <name> [words], /template save\|delete <name>                                                     |
 | `/web-search <query>`     | search the web via Tavily; results are shown and added to context                                                                   |
 | `/mcp`                    | MCP server status; `/mcp add\|remove <name>`, `/mcp login\|logout <name>`, `/mcp trust` ([more](docs/CONFIGURATION.md#mcp-servers)) |
 | `/skills`                 | list discovered skills (project + user-global) and why any were skipped                                                             |

package/dist/agent/compactor.js

@@ -1,5 +1,10 @@
+import { estimateHistoryTokens } from "./tokens.js";
 /** How many recent messages survive compaction untouched. */
 const KEEP_TAIL = 8;
+/** The briefing prompt shared by compaction and the one-shot /summarize. */
+export const SUMMARY_SYSTEM_PROMPT = "You summarize coding-session transcripts. Produce a dense briefing: the user's goals, " +
+    "key decisions, files created/modified (with paths), commands run and their outcomes, " +
+    "current state, and open items. Plain text, no preamble.";
 /**
  * Split history into an older part to summarize and a recent tail to keep.
  * The tail never starts on a tool reply: the cut moves back to the assistant
@@ -61,8 +66,7 @@ export function fallbackSummary(toSummarize) {
     }
     return lines.join("\n");
 }
-/** Render messages as a plain-text transcript for the summarization request. */
-export function renderTranscript(messages) {
+/** Render messages as a plain-text transcript for the summarization request. */ export function renderTranscript(messages) {
     return messages
         .map((m) => {
         if (m.role === "tool") {
@@ -76,3 +80,22 @@ export function renderTranscript(messages) {
     })
         .join("\n\n");
 }
+/**
+ * Choose which messages the one-shot summary covers. The whole history when
+ * it fits comfortably; otherwise the newest messages that fit within half
+ * the context window (the summarization call needs headroom for its reply).
+ * Oldest drop first, and the selection never starts on a tool reply, so
+ * call/reply pairs stay together. Returns the selection and how many oldest
+ * messages were dropped.
+ */
+export function selectMessagesForSummary(history, contextWindow) {
+    const budget = Math.floor(contextWindow / 2);
+    let messages = history;
+    while (messages.length > 1 && estimateHistoryTokens(messages) > budget) {
+        messages = messages.slice(1);
+    }
+    while (messages.length > 1 && messages[0].role === "tool") {
+        messages = messages.slice(1);
+    }
+    return { messages, dropped: history.length - messages.length };
+}

package/dist/agent/loop.js

@@ -1,5 +1,5 @@
 import { isContextOverflowError } from "../provider/client.js";
-import { splitForCompaction, renderTranscript, fallbackSummary } from "./compactor.js";
+import { splitForCompaction, renderTranscript, fallbackSummary, selectMessagesForSummary, SUMMARY_SYSTEM_PROMPT, } from "./compactor.js";
 import { estimateHistoryTokens, estimateTokens } from "./tokens.js";
 import { buildSystemPrompt } from "./systemPrompt.js";
 import { NOOP_TRACER } from "../telemetry/tracer.js";
@@ -325,6 +325,29 @@ export class Agent {
             this.onCompactEnd?.();
         }
     }
+    /**
+     * One-shot briefing of the session so far, for display. Unlike compact(),
+     * this never touches the history — it just asks the model to summarize
+     * what happened and returns the text. A failure is reported, not degraded:
+     * nothing is being destroyed, so there is no need for the mechanical
+     * fallback that compaction uses.
+     */
+    async summarize(signal) {
+        this.kill.assertLive();
+        if (this.history.length <= 4) {
+            return "Nothing to summarize yet — the session just started.";
+        }
+        const { messages, dropped } = selectMessagesForSummary(this.history, this.contextWindow);
+        const result = await this.client.chat(this.getModel(), [
+            { role: "system", content: SUMMARY_SYSTEM_PROMPT },
+            { role: "user", content: renderTranscript(messages) },
+        ], [], { onTextDelta: () => { }, onReasoningDelta: () => { } }, signal, { tracer: this.tracer, parent: this.currentTurnSpan ?? undefined });
+        const summary = result.text.trim() || "(summary unavailable)";
+        return dropped > 0
+            ? `Session summary (most recent ${messages.length} messages — ` +
+                `${dropped} oldest omitted to fit the context window):\n\n${summary}`
+            : `Session summary:\n\n${summary}`;
+    }
     async doCompact(signal, compactSpan) {
         const { toSummarize, keep } = splitForCompaction(this.history);
         if (!toSummarize.length) {
@@ -344,9 +367,7 @@ export class Agent {
             const result = await this.client.chat(this.getModel(), [
                 {
                     role: "system",
-                    content: "You summarize coding-session transcripts. Produce a dense briefing: the user's goals, " +
-                        "key decisions, files created/modified (with paths), commands run and their outcomes, " +
-                        "current state, and open items. Plain text, no preamble.",
+                    content: SUMMARY_SYSTEM_PROMPT,
                 },
                 { role: "user", content: renderTranscript(toSummarize) },
             ], [], { onTextDelta: () => { }, onReasoningDelta: () => { } }, signal, { tracer: this.tracer, parent: compactSpan });

package/dist/commands/registry.js

@@ -10,6 +10,9 @@ import { scanPluginMcpServers } from "../plugins/mcp.js";
 import { listProviders } from "../config/config.js";
 import { expandCommand } from "./custom.js";
 import { recordCommandUse } from "../ui/recentCommands.js";
+import { allTemplates, applyTemplate, isValidName, lastUserText, loadTemplates, saveTemplates, } from "./templates.js";
+import { gitBranch, gitCommitsAhead, gitDefaultBranch, gitHasUpstream, gitPush, gitRefExists, gitRemoteUrl, gitUnpushedCount, } from "../git/git.js";
+import { createPullRequest, findOpenPullRequest, parseGitHubRemote, parsePrFlags, prBodyFor, prTitleFor, resolveGitHubToken, } from "../git/pr.js";
 import { artifactExists, artifactPath, BACK_COMMAND, clearProjectState, DEFAULT_GATES, listProjects, loadProjectState, MAX_REVISITS, nextPhase, parseIdea, parsePhase, phaseBlocker, phaseDoneMessage, phaseIndex, phasePrompt, planRun, prefillAfter, renameProject, resumeProject, revisitsRemaining, saveProjectState, shouldStopAfter, staleArtifacts, takeRevisit, PHASE_COMMAND, PHASE_ORDER, PHASE_SUMMARY, slugify, } from "../agent/workflow.js";
 const WORKFLOW = "Workflow";
 const SESSION = "Session";
@@ -92,11 +95,26 @@ export const BUILTIN_COMMANDS = [
         description: "have the agent stage and commit the current changes",
         category: SESSION,
     },
+    {
+        name: "/pr",
+        description: "push the branch and open a GitHub PR: /pr [--draft] [--title T] [--body B] [--base BR]",
+        category: SESSION,
+    },
     {
         name: "/compact",
         description: "summarize older conversation to free context space",
         category: SESSION,
     },
+    {
+        name: "/summarize",
+        description: "one-shot summary of the session so far (history is left untouched)",
+        category: SESSION,
+    },
+    {
+        name: "/template",
+        description: "prompt templates: list, /template <name> [words], /template save|delete <name>",
+        category: SESSION,
+    },
     { name: "/clear", description: "start a fresh conversation", category: SESSION },
     {
         name: "/undo",
@@ -803,6 +821,79 @@ const handlers = {
             ctx.setPhase("input");
         });
     },
+    "/template": (ctx) => {
+        ctx.addItem({ kind: "user", text: ctx.raw.trim() });
+        const say = (text) => ctx.addItem({ kind: "info", text });
+        const custom = loadTemplates();
+        const all = allTemplates(custom);
+        const arg = ctx.arg.trim();
+        if (!arg) {
+            const names = Object.keys(all).sort();
+            if (!names.length) {
+                say("No prompt templates yet. Save your last message as one: /template save <name>");
+                return;
+            }
+            const lines = names.map((n) => custom[n] !== undefined ? `  ${n}  (yours)` : `  ${n}  (built-in)`);
+            say("Prompt templates — `/template <name> [words...]` drops one into the input line:\n" +
+                lines.join("\n") +
+                "\n\nSave your last message: `/template save <name>` · remove one: `/template delete <name>`");
+            return;
+        }
+        const [sub, ...rest] = arg.split(/\s+/);
+        if (sub === "save" || sub === "delete") {
+            const name = rest[0] ?? "";
+            if (!isValidName(name)) {
+                say(`Usage: /template ${sub} <name> — letters, numbers, - and _ only, max 32 chars.`);
+                return;
+            }
+            if (sub === "save") {
+                const text = lastUserText(ctx.agent.history);
+                if (!text) {
+                    say("Nothing to save — send a message first, then `/template save <name>`.");
+                    return;
+                }
+                custom[name] = text;
+                saveTemplates(custom);
+                say(`Saved template "${name}" (${text.length} chars). Use it: /template ${name}`);
+            }
+            else {
+                if (custom[name] === undefined) {
+                    say(`No saved template named "${name}". Built-ins can't be deleted.`);
+                    return;
+                }
+                delete custom[name];
+                saveTemplates(custom);
+                say(`Deleted template "${name}".`);
+            }
+            return;
+        }
+        const template = all[sub];
+        if (template === undefined) {
+            say(`No template named "${sub}". See /template for the list.`);
+            return;
+        }
+        // Into the input line, not executed: the user edits and hits Enter.
+        ctx.setPrefill(applyTemplate(template, rest.join(" ")));
+        say(`Template "${sub}" is in the input line — edit it and hit Enter. Nothing was sent.`);
+    },
+    "/summarize": (ctx) => {
+        ctx.addItem({ kind: "user", text: "/summarize" });
+        ctx.setPhase("working");
+        ctx.setActivity("Summarizing session…");
+        return ctx.agent
+            .summarize()
+            .then((summary) => {
+            ctx.addItem({ kind: "info", text: summary });
+        })
+            .catch((err) => ctx.addItem({
+            kind: "info",
+            text: `Summarization failed: ${err instanceof Error ? err.message : String(err)}`,
+        }))
+            .finally(() => {
+            ctx.setActivity(null);
+            ctx.setPhase("input");
+        });
+    },
     "/init": (ctx) => {
         ctx.addItem({ kind: "user", text: "/init" });
         return ctx.runAgent("Explore this repository (README, package/build files, src layout, test setup) and write " +
@@ -821,6 +912,84 @@ const handlers = {
             "and create a commit with a well-written conventional-commit message that describes " +
             `the change.${trailerInstruction} Do not push. Show the final commit hash and message.`);
     },
+    "/pr": async (ctx) => {
+        ctx.addItem({ kind: "user", text: ctx.raw.trim() });
+        const say = (text) => ctx.addItem({ kind: "info", text });
+        const opts = parsePrFlags(ctx.arg);
+        const ws = ctx.workspace;
+        const branch = gitBranch(ws);
+        if (!branch) {
+            say("Not a git repository — /pr needs one to push from.");
+            return;
+        }
+        const remote = gitRemoteUrl(ws);
+        const gh = remote ? parseGitHubRemote(remote) : null;
+        if (!gh) {
+            say("No GitHub origin remote found — /pr opens pull requests on GitHub.\n" +
+                "Set it with: git remote add origin <your-github-repo-url>");
+            return;
+        }
+        const base = opts.base ?? gitDefaultBranch(ws);
+        if (!gitRefExists(ws, base)) {
+            say(`Base branch "${base}" does not exist locally. Pass one that does: /pr --base <branch>`);
+            return;
+        }
+        if (branch === base) {
+            say(`You are on "${branch}", the default branch — a pull request needs a feature branch.\n` +
+                "Create one first: git checkout -b <name>");
+            return;
+        }
+        const auth = resolveGitHubToken();
+        if (!auth) {
+            say("No GitHub token found. Provide one of:\n" +
+                "  export GITHUB_TOKEN=<token>   (a classic or fine-grained PAT from github.com/settings/tokens)\n" +
+                "  gh auth login                (then /pr reads it via `gh auth token`)");
+            return;
+        }
+        const commits = gitCommitsAhead(ws, base);
+        if (commits.length === 0) {
+            say(`"${branch}" has no commits that "${base}" does not — nothing to open a PR for.`);
+            return;
+        }
+        // Push first: the PR is opened against the pushed branch. Only pushes
+        // when there is something to send — a no-op push that fails on network
+        // would otherwise block opening the PR for no reason.
+        if (!gitHasUpstream(ws, branch) || gitUnpushedCount(ws) > 0) {
+            say(`Pushing ${branch} to origin…`);
+            const err = gitPush(ws, branch, !gitHasUpstream(ws, branch));
+            if (err) {
+                say(err);
+                return;
+            }
+        }
+        const title = prTitleFor(commits, branch, opts.title);
+        const body = prBodyFor(commits, opts.body);
+        try {
+            const pr = await createPullRequest({
+                owner: gh.owner,
+                repo: gh.repo,
+                head: branch,
+                base,
+                title,
+                body,
+                draft: opts.draft,
+                token: auth.token,
+            });
+            say(`✓ PR #${pr.number} opened${opts.draft ? " (draft)" : ""}: ${pr.url}`);
+        }
+        catch (err) {
+            // A 422 almost always means the PR already exists — report it instead
+            // of failing on a duplicate.
+            if (err.alreadyExists) {
+                const existing = await findOpenPullRequest(gh.owner, gh.repo, branch, auth.token);
+                say(existing
+                    ? `A pull request for "${branch}" already exists: PR #${existing.number}: ${existing.url}`
+                    : "GitHub says a pull request for this branch already exists, but it could not be found.");
+                return;
+            }
+            say(err.message);
+        }
+    },
     "/flow-brainstorm": async (ctx) => {
         const req = takeFlowFlags(ctx.arg);
         if (req.error) {

package/dist/commands/templates.js

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_DIR } from "../config/config.js";
+import { writeFileAtomicSync } from "../atomicWrite.js";
+/**
+ * Prompt templates: named starter prompts kept in ~/.kritya/templates.json.
+ * `/template <name> [words...]` drops the template into the input line with
+ * `{{input}}` replaced by the words (nothing runs without the user hitting
+ * Enter); `/template save <name>` stores the last sent message as a template.
+ */
+const TEMPLATES_FILE = "templates.json";
+const INPUT_PLACEHOLDER = "{{input}}";
+const MAX_NAME_LENGTH = 32;
+const NAME_RE = /^[a-zA-Z0-9_-]+$/;
+/** Starter templates; a user template with the same name wins. */
+export const BUILTIN_TEMPLATES = {
+    review: "Review this diff for bugs, edge cases, and style issues:\n\n{{input}}",
+    explain: "Explain this code like I'm new to the codebase:\n\n{{input}}",
+};
+export function isValidName(name) {
+    return name.length > 0 && name.length <= MAX_NAME_LENGTH && NAME_RE.test(name);
+}
+/** The user's own templates from disk. Never throws — missing or broken file means none. */
+export function loadTemplates(dir = CONFIG_DIR) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, TEMPLATES_FILE), "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            if (typeof v === "string" && isValidName(k))
+                out[k] = v;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+export function saveTemplates(custom, dir = CONFIG_DIR) {
+    fs.mkdirSync(dir, { recursive: true });
+    writeFileAtomicSync(path.join(dir, TEMPLATES_FILE), JSON.stringify(custom, null, 2) + "\n");
+}
+/** Built-ins under the user's own, so a custom template can override a starter. */
+export function allTemplates(custom) {
+    return { ...BUILTIN_TEMPLATES, ...custom };
+}
+/**
+ * Fill `{{input}}` with the user's words. With no words, the placeholder is
+ * dropped rather than left visible; with no placeholder, the words are
+ * appended so `/template review src/foo.ts` still does something sensible.
+ */
+export function applyTemplate(template, input) {
+    const words = input.trim();
+    if (!template.includes(INPUT_PLACEHOLDER)) {
+        return words ? `${template.trimEnd()} ${words}` : template;
+    }
+    const filled = template.split(INPUT_PLACEHOLDER).join(words);
+    return words ? filled : filled.replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+/**
+ * The last prompt the user actually sent. Slash commands never reach the
+ * agent history, but anything starting with "/" is skipped anyway, along
+ * with non-text (multimodal) messages.
+ */
+export function lastUserText(history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+        const m = history[i];
+        if (m.role !== "user" || typeof m.content !== "string")
+            continue;
+        const text = m.content.trim();
+        if (!text || text.startsWith("/"))
+            continue;
+        return text;
+    }
+    return null;
+}

package/dist/config/models.js

@@ -68,7 +68,9 @@ export const CURATED_MODELS = [
         contextWindow: 1_048_576,
     },
     // Groq (https://console.groq.com/docs/models). Context windows verified
-    // against the docs table; both are 131,072.
+    // against the docs table; both are 131,072. llama-3.3-70b-versatile is
+    // enterprise-only on Groq ("Contact Sales", no self-serve), so it is
+    // deliberately not listed — it 404s on a normal API key.
     {
         id: "openai/gpt-oss-120b",
         label: "GPT-OSS 120B",
@@ -77,9 +79,10 @@ export const CURATED_MODELS = [
         contextWindow: 131_072,
     },
     {
-        id: "llama-3.3-70b-versatile",
-        label: "Llama 3.3 70B Versatile",
+        id: "openai/gpt-oss-20b",
+        label: "GPT-OSS 20B",
         provider: "groq",
+        note: "fast + cheap",
         contextWindow: 131_072,
     },
 ];

package/dist/git/git.js

@@ -17,6 +17,75 @@ export function gitBranch(cwd) {
     const out = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
     return out || null;
 }
+/** Remote URL of `origin`, or null when there is none. */
+export function gitRemoteUrl(cwd) {
+    const out = git(cwd, ["remote", "get-url", "origin"]);
+    return out || null;
+}
+/**
+ * The repo's default branch, from the origin/HEAD symref. Falls back to
+ * "main" when the symref is missing (a repo cloned without --no-remote-head
+ * oddities, or a remote the local clone has never fetched).
+ */
+export function gitDefaultBranch(cwd) {
+    const out = git(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+    const m = out && /^refs\/remotes\/origin\/(.+)$/.exec(out);
+    return m ? m[1] : "main";
+}
+/** Whether `branch` has an upstream configured. */
+export function gitHasUpstream(cwd, branch) {
+    return git(cwd, ["rev-parse", "--verify", `refs/remotes/${branch}@{upstream}`]) !== null;
+}
+/** Whether `ref` (branch, tag, …) exists locally. */
+export function gitRefExists(cwd, ref) {
+    return git(cwd, ["rev-parse", "--verify", ref]) !== null;
+}
+/** Commits on the current branch not yet on its upstream. 0 when there is no upstream. */
+export function gitUnpushedCount(cwd) {
+    const out = git(cwd, ["rev-list", "--count", "@{u}..HEAD"]);
+    const n = out === null ? NaN : parseInt(out, 10);
+    return Number.isFinite(n) ? n : 0;
+}
+/**
+ * Commits on HEAD that `base` does not have, oldest first. Empty when the
+ * branch is up to date with base (or on any git failure).
+ */
+export function gitCommitsAhead(cwd, base) {
+    // \x1e separates records, \x1f separates subject from body — both are
+    // control characters that cannot appear in a commit message as written by
+    // any sane tooling, and far less likely than newlines.
+    const out = git(cwd, ["log", "--reverse", "--format=%s%x1f%b%x1e", `${base}..HEAD`]);
+    if (!out)
+        return [];
+    return out
+        .split("\x1e")
+        .filter((rec) => rec.trim().length > 0)
+        .map((rec) => {
+        const [subject = "", body = ""] = rec.split("\x1f");
+        return { subject: subject.trim(), body: body.trim() };
+    });
+}
+/**
+ * Push the branch, setting the upstream when it has none. Returns an error
+ * message rather than throwing — the caller is a slash command reporting
+ * back to the user. The push runs under the user's own git credentials,
+ * exactly as if they had typed it themselves.
+ */
+export function gitPush(cwd, branch, setUpstream) {
+    const args = setUpstream ? ["push", "-u", "origin", branch] : ["push", "origin", branch];
+    try {
+        execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], timeout: 60000 });
+        return null;
+    }
+    catch (err) {
+        const stderr = err?.stderr?.toString().trim();
+        // Git's own error already says what went wrong (auth, rejected, no
+        // network); keep the first few lines so the user sees that, not a
+        // stack trace.
+        const detail = stderr ? stderr.split("\n").slice(0, 4).join("\n") : err.message;
+        return `git push failed:\n${detail}`;
+    }
+}
 /** Branch + working-tree status, capped at 30 lines; null outside a repo. */
 export function gitStatusShort(cwd) {
     const out = git(cwd, ["status", "--porcelain", "-b"]);

package/dist/git/pr.js

@@ -0,0 +1,204 @@
+import { execFileSync } from "node:child_process";
+/**
+ * Parse `owner/repo` out of the usual origin URL shapes:
+ * `https://github.com/owner/repo(.git)`, `git@github.com:owner/repo(.git)`,
+ * and `ssh://git@github.com/owner/repo(.git)`. Returns null for anything
+ * else — a non-GitHub remote, or a shape we do not recognise, is not
+ * something `/pr` can open a pull request against.
+ */
+export function parseGitHubRemote(url) {
+    const t = url.trim();
+    const m = /^https?:\/\/github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/.exec(t) ??
+        /^(?:ssh:\/\/)?git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/.exec(t) ??
+        /^ssh:\/\/git@github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/.exec(t);
+    if (!m)
+        return null;
+    return { owner: m[1], repo: m[2] };
+}
+/**
+ * Find a token for the GitHub API without asking the user to paste one into
+ * chat. `GITHUB_TOKEN` wins when set; otherwise `gh auth token` is tried
+ * when the gh CLI is installed and logged in. Returns null when neither
+ * works, and the caller tells the user exactly how to provide one.
+ */
+export function resolveGitHubToken(env = process.env) {
+    const fromEnv = env.GITHUB_TOKEN?.trim();
+    if (fromEnv)
+        return { token: fromEnv, source: "GITHUB_TOKEN" };
+    try {
+        const fromGh = execFileSync("gh", ["auth", "token"], {
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5000,
+        })
+            .toString()
+            .trim();
+        if (fromGh)
+            return { token: fromGh, source: "gh CLI" };
+    }
+    catch {
+        // gh missing or not logged in — fall through to null.
+    }
+    return null;
+}
+/**
+ * Pull the `/pr` flags out of the command argument. `--title` and `--body`
+ * take every word up to the next flag, so titles can contain spaces without
+ * quoting and flags can come in any order; `--base` takes one word (or
+ * `--base=<branch>`). A bare `/pr` takes no positional argument, so anything
+ * else is ignored.
+ */
+export function parsePrFlags(arg) {
+    const opts = { draft: false };
+    const tokens = arg.trim().split(/\s+/).filter(Boolean);
+    const isFlag = (t) => t === "--draft" ||
+        t === "--title" ||
+        t === "--body" ||
+        t === "--base" ||
+        t.startsWith("--base=");
+    let i = 0;
+    while (i < tokens.length) {
+        const t = tokens[i];
+        if (t === "--draft") {
+            opts.draft = true;
+            i += 1;
+        }
+        else if (t === "--title" || t === "--body") {
+            const words = [];
+            i += 1;
+            while (i < tokens.length && !isFlag(tokens[i])) {
+                words.push(tokens[i]);
+                i += 1;
+            }
+            const value = words.join(" ").trim() || undefined;
+            if (t === "--title")
+                opts.title = value;
+            else
+                opts.body = value;
+        }
+        else if (t === "--base" || t.startsWith("--base=")) {
+            const inline = t.startsWith("--base=") ? t.slice("--base=".length).trim() : "";
+            const next = tokens[i + 1];
+            if (inline) {
+                opts.base = inline;
+                i += 1;
+            }
+            else if (next && !isFlag(next)) {
+                opts.base = next;
+                i += 2;
+            }
+            else {
+                i += 1;
+            }
+        }
+        else {
+            i += 1;
+        }
+    }
+    return opts;
+}
+/**
+ * The PR title when the user did not pass `--title`. One commit ahead names
+ * itself; several get the branch name, since no single commit speaks for the
+ * change. An explicit `--title` always wins.
+ */
+export function prTitleFor(commits, branch, override) {
+    if (override?.trim())
+        return override.trim();
+    if (commits.length === 1)
+        return commits[0].subject || branch;
+    return branch;
+}
+/**
+ * The PR body when the user did not pass `--body`. One commit contributes
+ * its own body (often empty — fine); several become a list of subjects so
+ * the PR still says what it contains. An explicit `--body` always wins.
+ */
+export function prBodyFor(commits, override) {
+    if (override !== undefined)
+        return override;
+    if (commits.length <= 1)
+        return commits[0]?.body || undefined;
+    return commits.map((c) => `- ${c.subject}`).join("\n");
+}
+/**
+ * Create the pull request via the GitHub REST API. `fetchFn` is injectable
+ * so tests can fake the API without network access.
+ *
+ * A 422 from GitHub usually means a PR for the branch already exists — the
+ * caller then looks it up and reports its URL rather than failing.
+ */
+export async function createPullRequest(req, fetchFn = fetch) {
+    let res;
+    try {
+        res = await fetchFn(`https://api.github.com/repos/${req.owner}/${req.repo}/pulls`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${req.token}`,
+                Accept: "application/vnd.github+json",
+                "Content-Type": "application/json",
+                "User-Agent": "kritya",
+            },
+            body: JSON.stringify({
+                title: req.title,
+                head: req.head,
+                base: req.base,
+                body: req.body ?? "",
+                draft: req.draft,
+            }),
+        });
+    }
+    catch (err) {
+        throw new Error(`Could not reach api.github.com: ${err.message}`, {
+            cause: err,
+        });
+    }
+    if (res.status === 401) {
+        throw new Error("GitHub rejected the token (401). Check that GITHUB_TOKEN is valid, or re-run `gh auth login`.");
+    }
+    if (res.status === 403) {
+        throw new Error("GitHub refused the request (403) — the token may lack repo scope, or the API rate limit was hit.");
+    }
+    if (res.status === 404) {
+        throw new Error(`Repository ${req.owner}/${req.repo} not found (404). The token may not have access to it.`);
+    }
+    if (res.status === 422) {
+        const err = new Error("ALREADY_EXISTS");
+        err.alreadyExists = true;
+        throw err;
+    }
+    if (!res.ok) {
+        throw new Error(`GitHub API returned ${res.status}.`);
+    }
+    const data = (await res.json());
+    if (typeof data.number !== "number" || typeof data.html_url !== "string") {
+        throw new Error("GitHub's response did not include the pull request URL.");
+    }
+    return { number: data.number, url: data.html_url };
+}
+/**
+ * Find an already-open PR from `head` into any base, so `/pr` reports the
+ * existing one instead of failing on a duplicate. Returns null when there
+ * is none (or the lookup itself fails — absence of evidence either way).
+ */
+export async function findOpenPullRequest(owner, repo, head, token, fetchFn = fetch) {
+    try {
+        const res = await fetchFn(`https://api.github.com/repos/${owner}/${repo}/pulls?head=${owner}:${head}&state=open`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/vnd.github+json",
+                "User-Agent": "kritya",
+            },
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        const first = Array.isArray(data) ? data[0] : undefined;
+        if (first && typeof first.number === "number" && typeof first.html_url === "string") {
+            return { number: first.number, url: first.html_url };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.49-beta",
+  "version": "0.8.51-beta",
   "description": "Kritya — Superintelligence at your command line",
   "type": "module",
   "publishConfig": {