@mahmoudwael/opai 0.1.0

package/dist/dashboard.js

@@ -0,0 +1,183 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { configDir } from './config.js';
+import { accent, bold, danger, good, warning } from './ui.js';
+function dayKey(value) {
+    return `${value.getFullYear()}-${String(value.getMonth() + 1).padStart(2, '0')}-${String(value.getDate()).padStart(2, '0')}`;
+}
+function validHistory(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export class DashboardHistoryStore {
+    path;
+    writable = true;
+    constructor(path = join(configDir, 'dashboard-history.json')) {
+        this.path = path;
+    }
+    async all() {
+        try {
+            const value = JSON.parse(await readFile(this.path, 'utf8'));
+            return validHistory(value) ? value : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async save(value) {
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        await writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+        await rename(temp, this.path);
+    }
+    async record(provider, tickets, at = new Date()) {
+        if (!this.writable)
+            return;
+        const history = await this.all();
+        const snapshot = { date: dayKey(at), refreshedAt: at.getTime(), ticketIds: [...new Set(tickets.map(ticket => ticket.id))], total: tickets.length };
+        const previous = history[provider] ?? [];
+        const same = previous.find(item => item.date === snapshot.date);
+        if (same?.refreshedAt === snapshot.refreshedAt && same.total === snapshot.total && same.ticketIds.join('\0') === snapshot.ticketIds.join('\0'))
+            return;
+        history[provider] = [...previous.filter(item => item.date !== snapshot.date), snapshot]
+            .filter(item => item.refreshedAt >= at.getTime() - 35 * 86_400_000)
+            .sort((a, b) => a.refreshedAt - b.refreshedAt);
+        try {
+            await this.save(history);
+        }
+        catch {
+            this.writable = false;
+        }
+    }
+    async list(provider) { return (await this.all())[provider] ?? []; }
+}
+function activityTimes(session) {
+    const values = session.usedAt?.length ? session.usedAt : [session.createdAt, session.lastUsedAt].filter((value) => Boolean(value));
+    return [...new Set(values)].map(Date.parse).filter(Number.isFinite);
+}
+export function buildDashboard(tickets, refreshedAt, registry, provider, history, now = Date.now()) {
+    const groups = Object.entries(registry).filter(([key, sessions]) => key.startsWith(`${provider}:`) && sessions.length);
+    const sessions = groups.flatMap(([key, values]) => values.map(session => ({ key, session })));
+    const statuses = [...tickets.reduce((counts, ticket) => counts.set(ticket.status, (counts.get(ticket.status) ?? 0) + 1), new Map())]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    const start = new Date(now);
+    start.setHours(0, 0, 0, 0);
+    start.setDate(start.getDate() - 6);
+    const days = Array.from({ length: 7 }, (_, offset) => { const date = new Date(start); date.setDate(start.getDate() + offset); return date; });
+    const events = sessions.flatMap(item => activityTimes(item.session).map(at => ({ ...item, at })));
+    const activity = days.map(date => ({ label: new Intl.DateTimeFormat(undefined, { weekday: 'narrow' }).format(date), count: events.filter(event => dayKey(new Date(event.at)) === dayKey(date)).length }));
+    const touched = new Set(events.filter(event => event.at >= start.getTime() && event.at <= now).map(event => event.key));
+    const recentEvent = [...events].filter(event => event.at <= now).sort((a, b) => b.at - a.at)[0];
+    const recentTicket = recentEvent?.session.ticket;
+    const snapshots = history.filter(item => item.refreshedAt >= start.getTime() && item.refreshedAt <= now).sort((a, b) => a.refreshedAt - b.refreshedAt);
+    const cleared = new Set();
+    for (let index = 1; index < snapshots.length; index++) {
+        const current = new Set(snapshots[index].ticketIds);
+        for (const id of snapshots[index - 1].ticketIds)
+            if (!current.has(id))
+                cleared.add(id);
+    }
+    return {
+        open: tickets.length,
+        bugs: tickets.filter(ticket => ticket.type === 'Bug').length,
+        stories: tickets.filter(ticket => ticket.type === 'User Story').length,
+        sessions: sessions.length,
+        resumable: groups.length,
+        refreshedAt,
+        statuses,
+        agents: { claude: sessions.filter(item => item.session.agent === 'claude').length, codex: sessions.filter(item => item.session.agent === 'codex').length },
+        activity,
+        trend: snapshots.map(item => ({ label: item.date.slice(5), count: item.total })),
+        touchedThisWeek: touched.size,
+        weeklyGoal: Math.max(tickets.length, touched.size),
+        clearedThisWeek: cleared.size,
+        clearGoal: Math.max(snapshots[0]?.total ?? tickets.length, cleared.size),
+        recent: recentEvent ? { id: recentEvent.key.slice(provider.length + 1), title: recentTicket?.title ?? `Ticket #${recentEvent.key.slice(provider.length + 1)}`, status: recentTicket?.status, agent: recentEvent.session.agent === 'claude' ? 'Claude' : 'Codex', at: recentEvent.at } : undefined
+    };
+}
+function bar(value, max, width = 12) {
+    const fill = max ? Math.round(value / max * width) : 0;
+    return `${'█'.repeat(fill)}${'░'.repeat(width - fill)}`;
+}
+function ago(value, now) {
+    const minutes = Math.max(0, Math.floor((now - value) / 60_000));
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    return hours < 24 ? `${hours}h ago` : `${Math.floor(hours / 24)}d ago`;
+}
+function spark(values) {
+    if (!values.length)
+        return 'No history yet';
+    const levels = [...'▁▂▃▄▅▆▇█'];
+    const max = Math.max(...values, 1);
+    return values.map(value => levels[Math.round(value / max * (levels.length - 1))]).join(' ');
+}
+function fit(value, width) {
+    const chars = [...value];
+    return chars.length > width ? `${chars.slice(0, Math.max(0, width - 1)).join('')}…` : value.padEnd(width);
+}
+const defaultPalette = {
+    heading: value => bold(accent(value)),
+    positive: good,
+    warning,
+    danger,
+    accent,
+    bold
+};
+function styledCell(raw, styled, width) {
+    return `${styled}${' '.repeat(Math.max(0, width - [...raw].length))}`;
+}
+export function renderDashboard(model, columns = process.stdout.columns ?? 80, now = Date.now(), palette = defaultPalette) {
+    const statusMax = Math.max(...model.statuses.map(([, count]) => count), 1);
+    const agentMax = Math.max(model.agents.claude, model.agents.codex, 1);
+    const width = Math.max(4, Math.min(8, Math.floor(columns / 10)));
+    const half = Math.max(30, Math.floor((columns - 5) / 2));
+    const statusCells = model.statuses.length ? model.statuses.map(([name, count]) => {
+        const chart = bar(count, statusMax, width);
+        const number = String(count).padStart(2);
+        return {
+            raw: `${fit(name, 14)} ${chart} ${number}`,
+            styled: `${fit(name, 14)} ${palette.accent(chart)} ${palette.bold(number)}`
+        };
+    }) : [{ raw: 'No cached tickets yet', styled: 'No cached tickets yet' }];
+    const statusRows = [];
+    for (let index = 0; index < statusCells.length; index += 2) {
+        const first = statusCells[index];
+        statusRows.push(`  ${styledCell(first.raw, first.styled, half)} ${statusCells[index + 1]?.styled ?? ''}`.trimEnd());
+    }
+    const trendGraph = spark(model.trend.map(item => item.count));
+    const trend = `${palette.accent(trendGraph)}${model.trend.length ? `  ${model.trend.map(item => item.label).join(' ')}` : ''}`;
+    const recentMeta = model.recent ? ` · ${model.recent.status ?? 'Status unavailable'} · ${model.recent.agent} · ${ago(model.recent.at, now)}` : '';
+    const recent = model.recent
+        ? `${palette.accent(`#${model.recent.id}`)}  ${palette.bold(fit(model.recent.title, Math.max(10, columns - recentMeta.length - model.recent.id.length - 7)).trimEnd())}${recentMeta}`
+        : 'No agent activity yet';
+    const claudeRaw = `Claude  ${bar(model.agents.claude, agentMax, width)} ${model.agents.claude}`;
+    const codexRaw = `Codex   ${bar(model.agents.codex, agentMax, width)} ${model.agents.codex}`;
+    const claudeStyled = `Claude  ${palette.accent(bar(model.agents.claude, agentMax, width))} ${palette.bold(String(model.agents.claude))}`;
+    const codexStyled = `Codex   ${palette.accent(bar(model.agents.codex, agentMax, width))} ${palette.bold(String(model.agents.codex))}`;
+    const activityGraph = spark(model.activity.map(item => item.count));
+    const questMessage = model.open === 0
+        ? palette.positive('(˶ᵔ ᵕ ᵔ˶)  Quest board clear!')
+        : model.clearedThisWeek
+            ? palette.positive(`( •̀ᴗ•́)⚔  ${model.clearedThisWeek} quest${model.clearedThisWeek === 1 ? '' : 's'} cleared this week!`)
+            : palette.warning(`( •̀ᴗ•́)✧  ${model.open} quest${model.open === 1 ? '' : 's'} await you!`);
+    const lines = [
+        `  ⚔  Open ${palette.warning(String(model.open))}   🐞 Bugs ${palette.danger(String(model.bugs))}   📜 Stories ${palette.accent(String(model.stories))}   ✦ Sessions ${palette.positive(String(model.sessions))}   ↻ ${model.refreshedAt ? ago(model.refreshedAt, now) : 'never'}`,
+        `  ▶  ${palette.positive(String(model.resumable))} ticket${model.resumable === 1 ? '' : 's'} ready to resume`,
+        '', `  ${palette.heading('QUEST STATUS')}`,
+        ...statusRows,
+        '', `  ${palette.heading(fit('AGENT PARTY', half))} ${palette.heading('WEEKLY QUESTS')}`,
+        `  ${styledCell(claudeRaw, claudeStyled, half)} Touched  [${palette.accent(bar(model.touchedThisWeek, model.weeklyGoal, width))}] ${palette.positive(`${model.touchedThisWeek}/${model.weeklyGoal}`)}`,
+        `  ${styledCell(codexRaw, codexStyled, half)} Cleared  [${palette.accent(bar(model.clearedThisWeek, model.clearGoal, width))}] ${palette.positive(`${model.clearedThisWeek}/${model.clearGoal}`)} from board`,
+        '', `  ${palette.heading(fit('7-DAY ACTIVITY', half))} ${palette.heading('OPEN QUEST TREND')}`,
+        `  ${styledCell(model.activity.map(item => item.label).join('  '), model.activity.map(item => item.label).join('  '), half)} ${trend}`,
+        `  ${palette.accent(activityGraph)}`,
+        '', `  ${palette.heading('LAST QUEST')}`,
+        `  ${recent}`,
+        '', `  ${questMessage}`
+    ];
+    return lines.join('\n');
+}

package/dist/launch-menu.js

@@ -0,0 +1,53 @@
+import { accent, bold, warning } from './ui.js';
+export function editablePromptConfig(message, current) {
+    return {
+        message,
+        default: current,
+        prefill: 'editable',
+        validate: value => value.includes('{{id}}') || 'Prompt template must contain {{id}}.'
+    };
+}
+function preview(value, max = 52) {
+    const chars = [...value];
+    return chars.length > max ? `${chars.slice(0, max - 1).join('')}…` : value;
+}
+function selectedValue(value) {
+    return value === 'Default' ? '(Default)' : value;
+}
+export function launchDefaultsSummary(model, effort) {
+    const defaultModel = model === 'Default';
+    const defaultEffort = effort === 'Default';
+    if (defaultModel && defaultEffort)
+        return 'Agent defaults';
+    const modelSummary = defaultModel ? 'Agent model' : model;
+    const effortSummary = defaultEffort ? 'Agent effort' : `${effort} effort`;
+    return `${modelSummary} · ${effortSummary}`;
+}
+export function promptDefaultsSummary(custom) {
+    return custom ? 'Custom' : 'Provider default';
+}
+export function launchDefaultsRow(label, summary) {
+    return `  ${label.padEnd(18)}  ${summary}`;
+}
+export function menuSectionHeader(label, width = 48) {
+    const content = ` ${label} `;
+    const remaining = Math.max(4, width - [...content].length);
+    const left = Math.floor(remaining / 2);
+    const right = remaining - left;
+    return `${'─'.repeat(left)}${content}${'─'.repeat(right)}`;
+}
+export function buildLaunchMenu(model, effort, prompt, focus = 'start', availability = {}) {
+    const modelWarning = availability.model === false ? warning(' · unavailable') : '';
+    const effortWarning = availability.effort === false ? warning(' · unavailable') : '';
+    return {
+        default: focus,
+        choices: [
+            { name: '▶  Start session', value: 'start' },
+            { name: `◈  Model · ${accent(bold(selectedValue(model)))}${modelWarning}`, value: 'model' },
+            { name: `✦  Effort · ${warning(bold(selectedValue(effort)))}${effortWarning}`, value: 'effort' },
+            { name: `✎  Prompt · ${accent(preview(prompt))}`, value: 'prompt' },
+            { name: '★  Save current options as defaults', value: 'save' },
+            { name: '↺  Reset prompt to configured default', value: 'reset-prompt' }
+        ]
+    };
+}

package/dist/launch-preferences.js

@@ -0,0 +1,91 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { configDir } from './config.js';
+import { isModelId } from './models.js';
+function emptyPreferences() {
+    return { agents: { claude: { model: null, effort: null }, codex: { model: null, effort: null } }, prompts: {} };
+}
+function optionalId(value, label) {
+    if (value === undefined || value === null)
+        return null;
+    if (!isModelId(value))
+        throw new Error(`Invalid ${label}: ${JSON.stringify(value)}.`);
+    return value;
+}
+function validateTemplate(value) {
+    if (typeof value !== 'string' || !value.includes('{{id}}'))
+        throw new Error('Prompt template must contain {{id}}.');
+    return value;
+}
+export class LaunchPreferenceStore {
+    path;
+    constructor(path = join(configDir, 'launch-preferences.json')) {
+        this.path = path;
+    }
+    async all() {
+        let raw;
+        try {
+            raw = JSON.parse(await readFile(this.path, 'utf8'));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return emptyPreferences();
+            throw error;
+        }
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error('Invalid launch preferences file.');
+        const value = raw;
+        const rawAgents = value.agents && typeof value.agents === 'object' && !Array.isArray(value.agents) ? value.agents : {};
+        const agents = {};
+        for (const agent of ['claude', 'codex']) {
+            const entry = rawAgents[agent] && typeof rawAgents[agent] === 'object' && !Array.isArray(rawAgents[agent]) ? rawAgents[agent] : {};
+            agents[agent] = { model: optionalId(entry.model, `${agent} model`), effort: optionalId(entry.effort, `${agent} effort`) };
+        }
+        const prompts = {};
+        if (value.prompts !== undefined && (!value.prompts || typeof value.prompts !== 'object' || Array.isArray(value.prompts)))
+            throw new Error('Invalid launch prompt preferences.');
+        for (const [provider, entry] of Object.entries((value.prompts ?? {}))) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+                throw new Error(`Invalid prompt preferences for ${provider}.`);
+            const source = entry;
+            const normalized = {};
+            if (source.bug !== undefined)
+                normalized.bug = validateTemplate(source.bug);
+            if (source.userStory !== undefined)
+                normalized.userStory = validateTemplate(source.userStory);
+            if (Object.keys(normalized).length)
+                prompts[provider] = normalized;
+        }
+        return { agents, prompts };
+    }
+    async save(value) {
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        await writeFile(temp, JSON.stringify(value, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        await rename(temp, this.path);
+    }
+    async setAgent(agent, defaults) {
+        const value = await this.all();
+        value.agents[agent] = {
+            model: optionalId(defaults.model, `${agent} model`),
+            effort: optionalId(defaults.effort, `${agent} effort`)
+        };
+        await this.save(value);
+    }
+    async setPrompt(provider, kind, template) {
+        const value = await this.all();
+        if (template === null) {
+            if (value.prompts[provider]) {
+                delete value.prompts[provider][kind];
+                if (!Object.keys(value.prompts[provider]).length)
+                    delete value.prompts[provider];
+            }
+        }
+        else {
+            value.prompts[provider] ??= {};
+            value.prompts[provider][kind] = validateTemplate(template);
+        }
+        await this.save(value);
+    }
+}

package/dist/list-cache.js

@@ -0,0 +1,79 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { configDir } from './config.js';
+export function isTicketList(value) {
+    return Array.isArray(value) && value.every(item => item && typeof item.id === 'string' && typeof item.provider === 'string' && typeof item.title === 'string' && ['Bug', 'User Story', 'Unsupported'].includes(item.type) && typeof item.typeLabel === 'string' && typeof item.status === 'string' && (item.priority === undefined || (item.priority && typeof item.priority.id === 'string' && typeof item.priority.name === 'string')));
+}
+export function isSavedQueryList(value) {
+    return Array.isArray(value) && value.every(item => item && typeof item.id === 'string' && typeof item.name === 'string');
+}
+export class ListCache {
+    namespace;
+    ttlMs;
+    valid;
+    root;
+    now;
+    values = new Map();
+    constructor(namespace, ttlMs, valid, root = join(configDir, 'cache'), now = Date.now) {
+        this.namespace = namespace;
+        this.ttlMs = ttlMs;
+        this.valid = valid;
+        this.root = root;
+        this.now = now;
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0)
+            throw new Error('Cache TTL must be positive.');
+    }
+    path(key) {
+        const digest = createHash('sha256').update(JSON.stringify([this.namespace, key])).digest('hex');
+        return join(this.root, `${digest}.json`);
+    }
+    fresh(entry) {
+        const age = this.now() - entry.fetchedAt;
+        return age >= 0 && age < this.ttlMs;
+    }
+    async read(key) {
+        try {
+            const entry = JSON.parse(await readFile(this.path(key), 'utf8'));
+            if (entry.version === 1 && typeof entry.fetchedAt === 'number' && this.valid(entry.value))
+                return entry;
+        }
+        catch { }
+        return undefined;
+    }
+    async write(key, entry) {
+        await mkdir(this.root, { recursive: true, mode: 0o700 });
+        const destination = this.path(key);
+        const temp = `${destination}.${randomUUID()}.tmp`;
+        await writeFile(temp, JSON.stringify(entry), { mode: 0o600, flag: 'wx' });
+        await rename(temp, destination);
+    }
+    async peek(key) {
+        const entry = this.values.get(key) ?? await this.read(key);
+        return entry ? { fetchedAt: entry.fetchedAt, value: entry.value } : undefined;
+    }
+    async get(key, load, refresh = false) {
+        if (!refresh) {
+            const memory = this.values.get(key);
+            if (memory && this.fresh(memory))
+                return memory.value;
+            const disk = await this.read(key);
+            if (disk && this.fresh(disk)) {
+                this.values.set(key, disk);
+                return disk.value;
+            }
+        }
+        const value = await load();
+        if (!this.valid(value))
+            throw new Error('Invalid list response.');
+        const entry = { version: 1, fetchedAt: this.now(), value };
+        this.values.set(key, entry);
+        try {
+            await this.write(key, entry);
+        }
+        catch {
+            console.warn('Could not save the OPAI list cache; this session will still use it.');
+        }
+        return value;
+    }
+}

package/dist/models.js

@@ -0,0 +1,50 @@
+const CLAUDE_ALIASES = ['sonnet', 'opus', 'haiku'];
+export function isModelId(value) {
+    return typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:/@+\[\]-]{0,199}$/.test(value);
+}
+function validateModelId(agent, value) {
+    if (!isModelId(value))
+        throw new Error(`Invalid ${agent} model ID: ${JSON.stringify(value)}.`);
+}
+export function parseConfiguredModels(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('models must be an object.');
+    const models = value;
+    for (const agent of ['claude', 'codex']) {
+        const entries = models[agent];
+        if (entries === undefined)
+            continue;
+        if (!Array.isArray(entries))
+            throw new Error(`models.${agent} must be an array of model IDs.`);
+        for (const model of entries)
+            validateModelId(agent, model);
+    }
+    return {
+        ...(models.claude !== undefined ? { claude: [...models.claude] } : {}),
+        ...(models.codex !== undefined ? { codex: [...models.codex] } : {})
+    };
+}
+export function modelOptions(agent, configured = []) {
+    for (const model of configured)
+        validateModelId(agent, model);
+    const models = agent === 'claude' ? [...CLAUDE_ALIASES, ...configured] : configured;
+    const unique = [...new Set(models)];
+    return [
+        { name: 'Default', value: null },
+        ...unique.map(value => ({ name: CLAUDE_ALIASES.includes(value) ? value[0].toUpperCase() + value.slice(1) : value, value }))
+    ];
+}
+export function resolvePreferredModel(agent, preference, configured = []) {
+    if (preference === null)
+        return null;
+    validateModelId(agent, preference);
+    if (!modelOptions(agent, configured).some(option => option.value === preference)) {
+        throw new Error(`Saved ${agent} model ${JSON.stringify(preference)} is not available. Change Launch defaults or add it to config.json.`);
+    }
+    return preference;
+}
+export function modelLabel(model) {
+    return model === null ? 'Default' : model;
+}

package/dist/providers/openproject.js

@@ -0,0 +1,120 @@
+function linkId(link) { const match = link?.href?.match(/\/(\d+)$/); return match ? Number(match[1]) : undefined; }
+export class OpenProjectProvider {
+    config;
+    token;
+    request;
+    identity;
+    base;
+    constructor(config, token, request = fetch) {
+        this.config = config;
+        this.token = token;
+        this.request = request;
+        this.identity = `openproject@${config.instanceId}`;
+        this.base = config.url.replace(/\/+$/, '');
+    }
+    normalize(wp) {
+        if (!Number.isInteger(wp.id) || !wp.subject || !wp._links)
+            throw new Error('Invalid OpenProject work package response.');
+        const typeId = linkId(wp._links.type);
+        const type = typeId === this.config.bugTypeId ? 'Bug' : typeId === this.config.userStoryTypeId ? 'User Story' : 'Unsupported';
+        const typeLabel = wp._links.type?.title ?? 'Unknown';
+        const priorityId = linkId(wp._links.priority);
+        const priority = priorityId !== undefined || wp._links.priority?.title
+            ? { id: priorityId === undefined ? 'unknown' : String(priorityId), name: wp._links.priority?.title ?? 'Unknown' }
+            : undefined;
+        return { id: String(wp.id), provider: this.identity, title: wp.subject, type, typeLabel, status: wp._links.status?.title ?? 'Unknown', priority, url: `${this.base}/work_packages/${wp.id}` };
+    }
+    promptTemplate(kind) {
+        const configured = this.config.promptTemplates?.[kind];
+        const template = configured ?? (kind === 'bug' ? 'fix openproject bug {{id}}' : 'implement openproject user story {{id}}');
+        if (typeof template !== 'string' || !template.includes('{{id}}'))
+            throw new Error(`OpenProject ${kind} prompt template must contain {{id}}.`);
+        return template;
+    }
+    prompt(ticket, action, override) {
+        if (ticket.provider !== this.identity)
+            throw new Error('Ticket belongs to another provider.');
+        const kind = action === 'fix' && ticket.type === 'Bug' ? 'bug' : action === 'implement' && ticket.type === 'User Story' ? 'userStory' : undefined;
+        if (!kind)
+            throw new Error(`No ${action} action for ${ticket.type} tickets.`);
+        const template = override ?? this.promptTemplate(kind);
+        if (typeof template !== 'string' || !template.includes('{{id}}'))
+            throw new Error(`OpenProject ${kind} prompt template must contain {{id}}.`);
+        return template.replaceAll('{{id}}', ticket.id);
+    }
+    async getJson(path) {
+        let response;
+        try {
+            response = await this.request(`${this.base}${path}`, { method: 'GET', headers: { Authorization: `Basic ${Buffer.from(`apikey:${this.token}`).toString('base64')}`, Accept: 'application/hal+json' } });
+        }
+        catch (error) {
+            const cause = error.cause?.code;
+            throw new Error(`Could not connect to OpenProject at ${this.base}${cause ? ` (${cause})` : ''}. Check openproject.url, DNS, VPN, and TLS.`, { cause: error });
+        }
+        if (!response.ok)
+            throw new Error(`OpenProject API returned HTTP ${response.status}${response.status === 401 ? ' (check API token)' : ''}.`);
+        try {
+            return await response.json();
+        }
+        catch {
+            throw new Error('OpenProject returned invalid JSON.');
+        }
+    }
+    async listAssigned() {
+        const user = await this.getJson('/api/v3/users/me');
+        if (!Number.isInteger(user.id))
+            throw new Error('OpenProject did not return a user ID.');
+        const filters = JSON.stringify([{ assignee: { operator: '=', values: [String(user.id)] } }, { status: { operator: 'o', values: [] } }]);
+        const result = [];
+        for (let offset = 1;;) {
+            const query = new URLSearchParams({ filters, offset: String(offset), pageSize: '100' });
+            const page = await this.getJson(`/api/v3/work_packages?${query}`);
+            const elements = page._embedded?.elements;
+            if (!Array.isArray(elements) || !Number.isInteger(page.total))
+                throw new Error('Invalid OpenProject work package collection.');
+            result.push(...elements.map(wp => this.normalize(wp)));
+            if (!elements.length || result.length >= page.total)
+                break;
+            offset += 1;
+        }
+        return result;
+    }
+    async listSavedQueries() {
+        const queries = [];
+        for (let offset = 1;; offset++) {
+            const params = new URLSearchParams({ offset: String(offset), pageSize: '100' });
+            const page = await this.getJson(`/api/v3/queries?${params}`);
+            const elements = page._embedded?.elements;
+            if (!Array.isArray(elements) || !Number.isInteger(page.total))
+                throw new Error('Invalid OpenProject query collection.');
+            for (const query of elements) {
+                if (!Number.isInteger(query.id) || typeof query.name !== 'string')
+                    throw new Error('Invalid OpenProject saved query.');
+                queries.push({ id: String(query.id), name: query.name });
+            }
+            if (!elements.length || queries.length >= page.total)
+                return queries;
+        }
+    }
+    async listQueryTickets(queryId) {
+        if (!/^\d+$/.test(queryId))
+            throw new Error('OpenProject query ID must be numeric.');
+        const tickets = [];
+        for (let offset = 1;; offset++) {
+            const params = new URLSearchParams({ offset: String(offset), pageSize: '100' });
+            const query = await this.getJson(`/api/v3/queries/${queryId}?${params}`);
+            const results = query._embedded?.results;
+            const elements = results?._embedded?.elements;
+            if (!results || !Array.isArray(elements) || !Number.isInteger(results.total))
+                throw new Error('Invalid OpenProject query results.');
+            tickets.push(...elements.map(wp => this.normalize(wp)));
+            if (!elements.length || tickets.length >= results.total)
+                return tickets;
+        }
+    }
+    async get(id) {
+        if (!/^\d+$/.test(id))
+            throw new Error('OpenProject ticket ID must be numeric.');
+        return this.normalize(await this.getJson(`/api/v3/work_packages/${id}`));
+    }
+}

package/dist/providers/types.js

@@ -0,0 +1 @@
+export function ticketKey(ticket) { return `${ticket.provider}:${ticket.id}`; }

package/dist/query-preferences.js

@@ -0,0 +1,76 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { configDir } from './config.js';
+export function orderedQueries(queries, preferences, provider) {
+    return [...queries].sort((a, b) => {
+        const left = preferences[`${provider}:${a.id}`];
+        const right = preferences[`${provider}:${b.id}`];
+        if (Boolean(left?.pinned) !== Boolean(right?.pinned))
+            return left?.pinned ? -1 : 1;
+        const recent = Date.parse(right?.lastOpenedAt ?? '') - Date.parse(left?.lastOpenedAt ?? '');
+        if (Number.isFinite(recent) && recent !== 0)
+            return recent;
+        if (left?.lastOpenedAt && !right?.lastOpenedAt)
+            return -1;
+        if (!left?.lastOpenedAt && right?.lastOpenedAt)
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+export function querySections(queries, preferences, provider) {
+    const sections = { pinned: [], recent: [], all: [] };
+    for (const query of orderedQueries(queries, preferences, provider)) {
+        const preference = preferences[`${provider}:${query.id}`];
+        if (preference?.pinned)
+            sections.pinned.push(query);
+        else if (preference?.lastOpenedAt)
+            sections.recent.push(query);
+        else
+            sections.all.push(query);
+    }
+    return ['pinned', 'recent', 'all']
+        .filter(kind => sections[kind].length > 0)
+        .map(kind => ({ kind, queries: sections[kind] }));
+}
+export class QueryPreferencesStore {
+    path;
+    now;
+    constructor(path = join(configDir, 'query-preferences.json'), now = () => new Date()) {
+        this.path = path;
+        this.now = now;
+    }
+    async all() {
+        try {
+            const value = JSON.parse(await readFile(this.path, 'utf8'));
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                throw new Error('Invalid query preferences.');
+            return value;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return {};
+            throw error;
+        }
+    }
+    async save(value) {
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        await writeFile(temp, JSON.stringify(value, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        await rename(temp, this.path);
+    }
+    async opened(provider, id) {
+        const value = await this.all();
+        const key = `${provider}:${id}`;
+        value[key] = { pinned: Boolean(value[key]?.pinned), lastOpenedAt: this.now().toISOString() };
+        await this.save(value);
+    }
+    async togglePin(provider, id) {
+        const value = await this.all();
+        const key = `${provider}:${id}`;
+        const pinned = !value[key]?.pinned;
+        value[key] = { ...value[key], pinned };
+        await this.save(value);
+        return pinned;
+    }
+}