@yannelli/paseo-linear-plugin 0.1.0 → 0.3.0

package/shared/markdown.ts

@@ -0,0 +1,416 @@
+// Small parser for Linear-flavored markdown. Pure and runtime-neutral so the client
+// renderer and the tests share it. Unknown syntax falls back to text; it never throws.
+
+export type MarkdownText = { type: "text"; text: string };
+export type MarkdownCode = { type: "code"; text: string };
+export type MarkdownSpan = { type: "strong" | "emphasis" | "strike"; children: MarkdownInline[] };
+export type MarkdownLink = { type: "link"; url: string; children: MarkdownInline[] };
+export type MarkdownBreak = { type: "break" };
+export type MarkdownInline =
+  | MarkdownText
+  | MarkdownCode
+  | MarkdownSpan
+  | MarkdownLink
+  | MarkdownBreak;
+
+export type MarkdownHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type MarkdownAlign = "left" | "center" | "right" | null;
+export type MarkdownTableRow = MarkdownInline[][];
+/** `checked` is null for a plain item, true or false for a task item. */
+export type MarkdownListItem = { checked: boolean | null; children: MarkdownBlock[] };
+
+export type MarkdownBlock =
+  | { type: "heading"; level: MarkdownHeadingLevel; children: MarkdownInline[] }
+  | { type: "paragraph"; children: MarkdownInline[] }
+  | { type: "list"; ordered: boolean; start: number; items: MarkdownListItem[] }
+  | { type: "code"; language: string | null; text: string }
+  | { type: "blockquote"; children: MarkdownBlock[] }
+  | { type: "rule" }
+  | { type: "table"; align: MarkdownAlign[]; header: MarkdownTableRow; rows: MarkdownTableRow[] };
+
+const MAX_DEPTH = 12;
+const HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?(?:[ \t]+#+)?[ \t]*$/;
+const RULE = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+const FENCE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+const QUOTE = /^ {0,3}> ?/;
+const LIST_ITEM = /^([ \t]*)([-*+]|\d{1,9}[.)])(?:([ \t]+)(.*))?$/;
+const TASK = /^\[([ xX])\](?:[ \t]+|$)/;
+const DIVIDER = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+
+export function safeUrl(url: string): string | null {
+  const trimmed = url.trim();
+  return /^(?:https?:\/\/|mailto:)\S/i.test(trimmed) ? trimmed : null;
+}
+
+export function parseMarkdown(source: string): MarkdownBlock[] {
+  const text = typeof source === "string" ? source : "";
+  try {
+    return parseBlocks(text.replace(/\r\n?/g, "\n").split("\n"), 0);
+  } catch {
+    return text.trim() ? [{ type: "paragraph", children: [{ type: "text", text }] }] : [];
+  }
+}
+
+function isBlank(line: string | undefined): boolean {
+  return line === undefined || /^[ \t]*$/.test(line);
+}
+
+// Leading whitespace in columns (tabs stop at multiples of 4), measured up to `limit`.
+function leading(line: string, limit = Infinity): { cols: number; chars: number } {
+  let cols = 0;
+  let chars = 0;
+  for (; chars < line.length && cols < limit; chars++) {
+    if (line[chars] === " ") cols += 1;
+    else if (line[chars] === "\t") cols += 4 - (cols % 4);
+    else break;
+  }
+  return { cols, chars };
+}
+
+const indentOf = (line: string) => leading(line).cols;
+
+function dedent(line: string, cols: number): string {
+  const lead = leading(line, cols);
+  return " ".repeat(Math.max(0, lead.cols - cols)) + line.slice(lead.chars);
+}
+
+type Fence = { indent: number; marker: string; language: string | null };
+
+function openFence(line: string): Fence | null {
+  const match = FENCE.exec(line);
+  if (!match || (match[2][0] === "`" && match[3].includes("`"))) return null;
+  const language = match[3].trim().split(/\s+/)[0] || null;
+  return { indent: match[1].length, marker: match[2], language };
+}
+
+function closesFence(line: string, marker: string): boolean {
+  const run = /^ {0,3}(`+|~+)[ \t]*$/.exec(line)?.[1];
+  return run !== undefined && run[0] === marker[0] && run.length >= marker.length;
+}
+
+// Escaped pipes become a placeholder so they survive the split, then turn back into "|".
+function splitRow(line: string): string[] {
+  const row = line.trim().replace(/\\\|/g, "\u0000").replace(/^\|/, "").replace(/\|$/, "");
+  return row.split("|").map((cell) => cell.replace(/\u0000/g, "|").trim());
+}
+
+function alignOf(cell: string): MarkdownAlign {
+  const left = cell.startsWith(":");
+  const right = cell.endsWith(":");
+  return left && right ? "center" : right ? "right" : left ? "left" : null;
+}
+
+function isTableStart(lines: string[], i: number): boolean {
+  const divider = lines[i + 1];
+  if (divider === undefined || !lines[i].includes("|") || !divider.includes("|")) return false;
+  return DIVIDER.test(divider) && splitRow(lines[i]).length === splitRow(divider).length;
+}
+
+// True when the line starts a block that may interrupt a paragraph. Lists only
+// interrupt with a non-empty bullet or a list starting at 1, as in CommonMark.
+function startsBlock(lines: string[], i: number): boolean {
+  const line = lines[i];
+  if (HEADING.test(line) || RULE.test(line) || QUOTE.test(line) || openFence(line)) return true;
+  if (isTableStart(lines, i)) return true;
+  const item = LIST_ITEM.exec(line);
+  if (!item?.[4]?.trim()) return false;
+  return !/\d/.test(item[2]) || parseInt(item[2], 10) === 1;
+}
+
+function parseBlocks(lines: string[], depth: number): MarkdownBlock[] {
+  const blocks: MarkdownBlock[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const fence = openFence(line);
+    const heading = HEADING.exec(line);
+    if (isBlank(line)) i++;
+    else if (fence) i = parseFence(lines, i, fence, blocks);
+    else if (heading) {
+      const level = heading[1].length as MarkdownHeadingLevel;
+      blocks.push({ type: "heading", level, children: parseInline(heading[2] ?? "") });
+      i++;
+    } else if (RULE.test(line)) {
+      blocks.push({ type: "rule" });
+      i++;
+    } else if (depth < MAX_DEPTH && QUOTE.test(line)) i = parseQuote(lines, i, depth, blocks);
+    else if (depth < MAX_DEPTH && LIST_ITEM.test(line)) i = parseList(lines, i, depth, blocks);
+    else if (isTableStart(lines, i)) i = parseTable(lines, i, blocks);
+    else i = parseParagraph(lines, i, blocks);
+  }
+  return blocks;
+}
+
+function parseFence(lines: string[], start: number, fence: Fence, out: MarkdownBlock[]): number {
+  const body: string[] = [];
+  let i = start + 1;
+  while (i < lines.length && !closesFence(lines[i], fence.marker)) {
+    body.push(dedent(lines[i++], fence.indent));
+  }
+  out.push({ type: "code", language: fence.language, text: body.join("\n") });
+  return i + 1;
+}
+
+function parseQuote(lines: string[], start: number, depth: number, out: MarkdownBlock[]): number {
+  const body: string[] = [];
+  let i = start;
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (QUOTE.test(line)) body.push(line.replace(QUOTE, ""));
+    else if (isBlank(line) || isBlank(body[body.length - 1]) || startsBlock(lines, i)) break;
+    else body.push(line);
+  }
+  out.push({ type: "blockquote", children: parseBlocks(body, depth + 1) });
+  return i;
+}
+
+function parseList(lines: string[], start: number, depth: number, out: MarkdownBlock[]): number {
+  const kind = (marker: string) => /\d/.test(marker);
+  const first = LIST_ITEM.exec(lines[start]);
+  const ordered = kind(first?.[2] ?? "-");
+  const items: MarkdownListItem[] = [];
+  let i = start;
+  let match = first;
+  while (match && kind(match[2]) === ordered) {
+    const indent = indentOf(match[1]);
+    const contentCol = indent + match[2].length + Math.min(match[3]?.length ?? 1, 4);
+    const task = TASK.exec(match[4] ?? "");
+    const body = [(match[4] ?? "").slice(task?.[0].length ?? 0)];
+    let j = i + 1;
+    // Lines indented 2+ columns past the marker belong to the item, as do blank lines
+    // followed by such a line. Unindented text is a lazy paragraph continuation.
+    while (j < lines.length) {
+      const line = lines[j];
+      if (isBlank(line)) {
+        let k = j;
+        while (k < lines.length && isBlank(lines[k])) k++;
+        if (k >= lines.length || indentOf(lines[k]) < indent + 2) break;
+        for (; j < k; j++) body.push("");
+      } else if (indentOf(line) >= indent + 2) {
+        body.push(dedent(line, contentCol));
+        j++;
+      } else if (LIST_ITEM.test(line) || startsBlock(lines, j)) break;
+      else {
+        body.push(line);
+        j++;
+      }
+    }
+    items.push({ checked: task ? task[1] !== " " : null, children: parseBlocks(body, depth + 1) });
+    i = j;
+    let k = j;
+    while (k < lines.length && isBlank(lines[k])) k++;
+    match = k < lines.length ? LIST_ITEM.exec(lines[k]) : null;
+    if (match && kind(match[2]) === ordered) i = k;
+  }
+  const startAt = ordered ? parseInt(first?.[2] ?? "1", 10) : 1;
+  out.push({ type: "list", ordered, start: startAt, items });
+  return Math.max(i, start + 1);
+}
+
+function parseTable(lines: string[], start: number, out: MarkdownBlock[]): number {
+  const header = splitRow(lines[start]);
+  const align = splitRow(lines[start + 1]).map(alignOf);
+  const cells = (row: string[]) => header.map((_, c) => parseInline(row[c] ?? ""));
+  const rows: MarkdownTableRow[] = [];
+  let i = start + 2;
+  while (i < lines.length && lines[i].includes("|") && !startsBlock(lines, i)) {
+    rows.push(cells(splitRow(lines[i++])));
+  }
+  out.push({ type: "table", align, header: cells(header), rows });
+  return i;
+}
+
+function parseParagraph(lines: string[], start: number, out: MarkdownBlock[]): number {
+  const body = [lines[start]];
+  let i = start + 1;
+  while (i < lines.length && !isBlank(lines[i]) && !startsBlock(lines, i)) body.push(lines[i++]);
+  out.push({ type: "paragraph", children: parseInline(joinLines(body)) });
+  return i;
+}
+
+// Soft wraps become spaces. Two trailing spaces or a trailing backslash become "\n",
+// which the inline parser turns into a break node.
+function joinLines(lines: string[]): string {
+  return lines
+    .map((raw, k) => {
+      const line = raw.trimStart();
+      if (k === lines.length - 1) return line.trimEnd();
+      if (/ {2,}$/.test(line)) return `${line.trimEnd()}\n`;
+      if (/(?:^|[^\\])\\$/.test(line)) return `${line.slice(0, -1)}\n`;
+      return `${line.trimEnd()} `;
+    })
+    .join("");
+}
+
+type Token = { nodes: MarkdownInline[]; end: number };
+
+const PUNCT = /[!-/:-@[-`{-~]/;
+const ESCAPED = /\\([!-/:-@[-`{-~])/g;
+// Letters and digits, approximated with ranges instead of \p{L} so older JS engines
+// parse it. Skips the general punctuation, symbol and emoji (surrogate) ranges.
+const ALNUM = /[0-9A-Za-zÀ-ɏͰ-῿Ⰰ-퟿豈-ￜ]/;
+const SPECIAL = /[\\\n`*_~[!<hH]/g;
+const AUTOLINK = /<(?:([a-z][a-z0-9+.-]{1,31}:[^\s<>]*)|([^\s<>@]+@[^\s<>@]+\.[^\s<>@]+))>/iy;
+const BARE_URL = /https?:\/\/[^\s<>]+/iy;
+// "(url)" or "(url "title")". The url is <wrapped> or may hold one level of balanced parens.
+const LINK_DEST =
+  /\([ \t]*(?:<([^<>\n]*)>|((?:[^\s()\\]|\\.|\((?:[^\s()\\]|\\.)*\))*))(?:[ \t\n]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?[ \t\n]*\)/y;
+const isSpace = (ch: string | undefined) => ch === undefined || /\s/.test(ch);
+const isWord = (ch: string | undefined) => ch !== undefined && ALNUM.test(ch);
+const textToken = (text: string, end: number): Token => ({ nodes: [{ type: "text", text }], end });
+
+// Caps delimiter and bracket scans per top-level inline run so that adversarial input
+// stays linear. Once spent, the remaining delimiters are kept as plain text.
+let scanBudget = 0;
+
+function parseInline(text: string, depth = 0, inLink = false): MarkdownInline[] {
+  if (depth === 0) scanBudget = 50000;
+  if (depth > MAX_DEPTH) return text ? [{ type: "text", text }] : [];
+  const out: MarkdownInline[] = [];
+  let i = 0;
+  while (i < text.length) {
+    const token = readToken(text, i, depth, inLink);
+    for (const node of token.nodes) push(out, node);
+    i = Math.max(token.end, i + 1);
+  }
+  return out;
+}
+
+function push(out: MarkdownInline[], node: MarkdownInline): void {
+  const last = out[out.length - 1];
+  if (node.type !== "text") out.push(node);
+  else if (last?.type === "text") last.text += node.text;
+  else if (node.text) out.push({ type: "text", text: node.text });
+}
+
+function readToken(text: string, i: number, depth: number, inLink: boolean): Token {
+  const ch = text[i];
+  const next = text[i + 1];
+  if (ch === "\\" && next !== undefined && PUNCT.test(next)) return textToken(next, i + 2);
+  if (ch === "\n") return { nodes: [{ type: "break" }], end: i + 1 };
+  if (ch === "`") {
+    const span = codeSpan(text, i);
+    if (span) return { nodes: [{ type: "code", text: span.text }], end: span.end };
+    const run = runLength(text, i);
+    return textToken("`".repeat(run), i + run);
+  }
+  if (ch === "*" || ch === "_" || ch === "~") return emphasis(text, i, depth, inLink);
+  if (!inLink) {
+    let token: Token | null = null;
+    if (ch === "[" || (ch === "!" && next === "[")) token = readLink(text, i, depth);
+    else if (ch === "<") token = readAutolink(text, i);
+    else if (ch === "h" || ch === "H") token = readBareUrl(text, i);
+    if (token) return token;
+  }
+  SPECIAL.lastIndex = i + 1;
+  const end = SPECIAL.exec(text)?.index ?? text.length;
+  return textToken(text.slice(i, end), end);
+}
+
+function runLength(text: string, i: number): number {
+  let n = 0;
+  while (text[i + n] === text[i]) n++;
+  return n;
+}
+
+function codeSpan(text: string, i: number): { text: string; end: number } | null {
+  const size = runLength(text, i);
+  for (let j = text.indexOf("`", i + size); j >= 0; j = text.indexOf("`", j)) {
+    const run = runLength(text, j);
+    if (run === size) {
+      let code = text.slice(i + size, j).replace(/\n/g, " ");
+      if (/^ .*[^ ].* $/.test(code)) code = code.slice(1, -1);
+      return { text: code, end: j + run };
+    }
+    j += run;
+  }
+  return null;
+}
+
+function emphasis(text: string, i: number, depth: number, inLink: boolean): Token {
+  const ch = text[i];
+  const run = runLength(text, i);
+  if (isSpace(text[i + run]) || (ch === "_" && isWord(text[i - 1]))) {
+    return textToken(text.slice(i, i + run), i + run);
+  }
+  const sizes = [3, 2, 1].filter((size) => size <= run && (ch !== "~" || size === 2));
+  for (const size of sizes) {
+    const close = findCloser(text, i + size, ch, size);
+    if (close < 0) continue;
+    const children = parseInline(text.slice(i + size, close), depth + 1, inLink);
+    let node: MarkdownInline = { type: size === 1 ? "emphasis" : "strong", children };
+    if (ch === "~") node = { type: "strike", children };
+    if (size === 3) node = { type: "strong", children: [{ type: "emphasis", children }] };
+    return { nodes: [node], end: close + size };
+  }
+  return textToken(ch, i + 1);
+}
+
+// Finds the closing delimiter run, skipping escapes, code spans and nested openers of
+// the same character. Returns the index where the closing `size` characters begin.
+function findCloser(text: string, from: number, ch: string, size: number): number {
+  let nested = 0;
+  let j = from;
+  while (j < text.length && scanBudget-- > 0) {
+    const c = text[j];
+    if (c === "\\") j += 2;
+    else if (c === "`") j = codeSpan(text, j)?.end ?? j + runLength(text, j);
+    else if (c !== ch) j++;
+    else {
+      const run = runLength(text, j);
+      const before = text[j - 1];
+      const after = text[j + run];
+      if (j > from && !isSpace(before) && !(ch === "_" && isWord(after))) {
+        const used = Math.min(nested, run);
+        nested -= used;
+        if (run - used >= size) return j + used;
+      } else if (!isSpace(after) && !(ch === "_" && isWord(before))) nested += run;
+      j += run;
+    }
+  }
+  return -1;
+}
+
+function readLink(text: string, i: number, depth: number): Token | null {
+  const image = text[i] === "!";
+  const open = image ? i + 1 : i;
+  let close = -1;
+  for (let j = open, level = 0; j < text.length && close < 0 && scanBudget-- > 0; j++) {
+    if (text[j] === "\\") j++;
+    else if (text[j] === "[") level++;
+    else if (text[j] === "]" && --level === 0) close = j;
+  }
+  LINK_DEST.lastIndex = close + 1;
+  const dest = close < 0 ? null : LINK_DEST.exec(text);
+  if (!dest) return null;
+  const target = (dest[1] ?? dest[2]).replace(ESCAPED, "$1");
+  let children = parseInline(text.slice(open + 1, close), depth + 1, true);
+  if (children.length === 0) children = [{ type: "text", text: image ? "image" : target }];
+  const url = safeUrl(target);
+  const end = close + 1 + dest[0].length;
+  return { nodes: url ? [{ type: "link", url, children }] : children, end };
+}
+
+function readAutolink(text: string, i: number): Token | null {
+  AUTOLINK.lastIndex = i;
+  const match = AUTOLINK.exec(text);
+  if (!match) return null;
+  const label: MarkdownInline[] = [{ type: "text", text: match[1] ?? match[2] }];
+  const url = safeUrl(match[1] ?? `mailto:${match[2]}`);
+  const end = i + match[0].length;
+  return { nodes: url ? [{ type: "link", url, children: label }] : label, end };
+}
+
+function readBareUrl(text: string, i: number): Token | null {
+  if (isWord(text[i - 1])) return null;
+  BARE_URL.lastIndex = i;
+  let url = BARE_URL.exec(text)?.[0] ?? "";
+  const count = (ch: string) => url.split(ch).length - 1;
+  while (/[.,:;!?'"*_~)\]]$/.test(url) && !(url.endsWith(")") && count("(") >= count(")"))) {
+    url = url.slice(0, -1);
+  }
+  const safe = safeUrl(url);
+  const label: MarkdownInline[] = [{ type: "text", text: url }];
+  if (!safe) return null;
+  return { nodes: [{ type: "link", url: safe, children: label }], end: i + url.length };
+}

package/shared/prompts.ts

@@ -0,0 +1,150 @@
+import type { IssueDetail } from "./linear";
+import type { AgentAction, LinearSettings, ProjectConfig } from "./settings";
+
+export const DEFAULT_TEMPLATES: Record<AgentAction, string> = {
+  implement: [
+    "You are working on Linear issue {{identifier}}: {{title}}",
+    "",
+    "{{issue}}",
+    "",
+    "Implement what this issue asks for on branch {{branch}}.",
+    "1. Read the relevant code and confirm the expected behavior before you edit.",
+    "2. Make the smallest complete change. Add or update tests where the project has them.",
+    "3. Run the project's checks and fix what fails.",
+    "4. Finish with a summary: what changed, how you verified it, and what is still open.",
+  ].join("\n"),
+  review: [
+    "Review the work for Linear issue {{identifier}}: {{title}}",
+    "",
+    "{{issue}}",
+    "",
+    "Compare the current changes with the issue. Use the linked pull request if there is one,",
+    "otherwise the diff of this branch against its base branch.",
+    "Report:",
+    "- Each requirement: met, partly met, or missing.",
+    "- Bugs, regressions, and risky changes, with file and line references.",
+    "- Missing or weak tests.",
+    "Do not edit files unless you are asked to.",
+  ].join("\n"),
+};
+
+export const TEMPLATE_VARIABLES = [
+  { name: "identifier", description: "Issue key, such as ENG-123" },
+  { name: "title", description: "Issue title" },
+  { name: "url", description: "Link to the issue in Linear" },
+  { name: "branch", description: "Branch name Linear suggests for the issue" },
+  { name: "issue", description: "Full issue snapshot: fields, description, sub-issues, comments" },
+] as const;
+
+export const ACTION_LABELS: Record<AgentAction, { title: string; verb: string; icon: string }> = {
+  implement: { title: "Implement", verb: "Start agent", icon: "Play" },
+  review: { title: "Review", verb: "Start review", icon: "ScanSearch" },
+};
+
+export interface IssueSnapshotOptions {
+  includeComments: boolean;
+}
+
+export function issueSnapshot(issue: IssueDetail, options: IssueSnapshotOptions): string {
+  const lines = [
+    `Linear issue ${issue.identifier}: ${issue.title}`,
+    `URL: ${issue.url}`,
+    `Team: ${issue.team.name}`,
+    `Status: ${issue.state.name}`,
+    `Priority: ${issue.priorityLabel}`,
+  ];
+  if (issue.assignee) lines.push(`Assignee: ${issue.assignee.displayName}`);
+  if (issue.project) lines.push(`Project: ${issue.project.name}`);
+  if (issue.labels.length > 0) {
+    lines.push(`Labels: ${issue.labels.map((label) => label.name).join(", ")}`);
+  }
+  if (issue.parent) lines.push(`Parent: ${issue.parent.identifier} ${issue.parent.title}`);
+  lines.push("", "Description:", issue.description?.trim() || "No description.");
+  if (issue.children.length > 0) {
+    lines.push("", "Sub-issues:");
+    for (const child of issue.children) {
+      lines.push(`- ${child.identifier} [${child.state.name}] ${child.title}`);
+    }
+  }
+  const links = issue.attachments.filter((attachment) => attachment.url);
+  if (links.length > 0) {
+    lines.push("", "Links:");
+    for (const link of links) lines.push(`- ${link.title}: ${link.url}`);
+  }
+  if (options.includeComments && issue.comments.length > 0) {
+    lines.push("", "Comments (oldest first):");
+    for (const comment of issue.comments) {
+      const author = comment.user?.displayName ?? "Unknown";
+      lines.push(`- ${author} (${comment.createdAt.slice(0, 10)}): ${comment.body.trim()}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export function baseTemplate(settings: LinearSettings, action: AgentAction): string {
+  const custom = settings.templates[action].trim();
+  return custom || DEFAULT_TEMPLATES[action];
+}
+
+export function actionTemplate(
+  settings: LinearSettings,
+  project: ProjectConfig | null,
+  action: AgentAction,
+): string {
+  const base = baseTemplate(settings, action);
+  const override = project?.[action];
+  if (!override || override.mode === "default" || !override.text.trim()) return base;
+  if (override.mode === "replace") return override.text.trim();
+  return `${base}\n\n${override.text.trim()}`;
+}
+
+export function renderTemplate(template: string, values: Record<string, string>): string {
+  return template.replace(/\{\{\s*([a-zA-Z]+)\s*\}\}/g, (match, name: string) =>
+    values[name] !== undefined ? values[name] : match,
+  );
+}
+
+export interface ComposePromptInput {
+  action: AgentAction;
+  issue: IssueDetail;
+  settings: LinearSettings;
+  project: ProjectConfig | null;
+  includeComments: boolean;
+  extraInstructions: string;
+}
+
+export function composePrompt(input: ComposePromptInput): string {
+  const { issue, project } = input;
+  const template = actionTemplate(input.settings, project, input.action);
+  const snapshot = issueSnapshot(issue, { includeComments: input.includeComments });
+  const sections = [
+    renderTemplate(template, {
+      identifier: issue.identifier,
+      title: issue.title,
+      url: issue.url,
+      branch: issue.branchName,
+      issue: snapshot,
+    }),
+  ];
+  // A template that drops {{issue}} still gets the snapshot so the agent never works blind.
+  if (!/\{\{\s*issue\s*\}\}/.test(template)) sections.push(snapshot);
+  const instructions = project?.instructions.trim();
+  if (instructions) sections.push(`Project instructions:\n${instructions}`);
+  const steps = project?.steps.map((step) => step.trim()).filter(Boolean) ?? [];
+  if (steps.length > 0) {
+    sections.push(
+      `Project steps:\n${steps.map((step, index) => `${index + 1}. ${step}`).join("\n")}`,
+    );
+  }
+  const extra = input.extraInstructions.trim();
+  if (extra) sections.push(`Additional instructions:\n${extra}`);
+  return sections.join("\n\n");
+}
+
+export function agentTitle(action: AgentAction, issue: { identifier: string; title: string }) {
+  const prefix = action === "review" ? "Review" : issue.identifier;
+  const title = action === "review" ? `${issue.identifier} ${issue.title}` : issue.title;
+  return `${prefix}: ${title}`.slice(0, 120);
+}
+
+export const AGENT_LABELS = { issue: "linear.issue", action: "linear.action" } as const;

package/shared/settings.ts

@@ -0,0 +1,68 @@
+import { defineSettings } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const AGENT_ACTIONS = ["implement", "review"] as const;
+export type AgentAction = (typeof AGENT_ACTIONS)[number];
+
+export const PROMPT_MODES = ["default", "append", "replace"] as const;
+export type PromptMode = (typeof PROMPT_MODES)[number];
+
+const ActionOverrideSchema = z.object({
+  mode: z.enum(PROMPT_MODES).default("default"),
+  text: z.string().default(""),
+});
+
+export const ProjectConfigSchema = z.object({
+  projectId: z.string(),
+  displayName: z.string(),
+  rootPath: z.string(),
+  teamIds: z.array(z.string()).default([]),
+  instructions: z.string().default(""),
+  steps: z.array(z.string()).default([]),
+  implement: ActionOverrideSchema.prefault({}),
+  review: ActionOverrideSchema.prefault({}),
+});
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+
+export const ISOLATIONS = ["worktree", "workspace"] as const;
+export type Isolation = (typeof ISOLATIONS)[number];
+
+export const linearSettings = defineSettings({
+  id: "linear",
+  scope: "host",
+  version: 1,
+  schema: z.object({
+    // Empty templates mean "use the built-in prompt" so improved defaults reach existing users.
+    templates: z
+      .object({ implement: z.string().default(""), review: z.string().default("") })
+      .prefault({}),
+    launch: z
+      .object({
+        provider: z.string().default(""),
+        isolation: z.enum(ISOLATIONS).default("worktree"),
+        includeComments: z.boolean().default(true),
+        moveToStarted: z.boolean().default(true),
+        assignToMe: z.boolean().default(true),
+      })
+      .prefault({}),
+    projects: z.array(ProjectConfigSchema).default([]),
+  }),
+});
+
+export type LinearSettings = z.output<typeof linearSettings.schema>;
+
+export function emptyProjectConfig(project: {
+  projectId: string;
+  displayName: string;
+  rootPath: string;
+}): ProjectConfig {
+  return ProjectConfigSchema.parse(project);
+}
+
+export function upsertProject(
+  settings: LinearSettings,
+  next: ProjectConfig,
+): LinearSettings["projects"] {
+  const others = settings.projects.filter((entry) => entry.projectId !== next.projectId);
+  return [...others, next];
+}

package/index.client.ts

@@ -1,7 +0,0 @@
-import type { PluginClientContext } from "@getpaseo/plugin/client";
-import { issueAttachments } from "./shared/issues";
-
-export default function contribute(client: PluginClientContext) {
-  client.addAttachmentSource(issueAttachments);
-  return () => {};
-}

package/server/issues.ts

@@ -1,10 +0,0 @@
-import type { PluginAttachmentSearchPayload, RpcInput } from "@getpaseo/plugin";
-import { searchIssuesRpc } from "../shared/issues";
-import { createLinearIssueSearch } from "./linear";
-
-export async function searchIssues({
-  query,
-}: RpcInput<typeof searchIssuesRpc>): Promise<PluginAttachmentSearchPayload> {
-  const linear = createLinearIssueSearch({ apiKey: process.env.LINEAR_API_KEY ?? "" });
-  return linear.search(query);
-}