acdev 1.0.2 → 1.0.4

package/src/jira.js

@@ -416,3 +416,174 @@ export async function transitionJiraIssue(key, targetStatusName, creds) {
     statusName: match.to?.name || want,
   };
 }
+
+/** Status names commonly used for “done / closed” when category is unavailable. */
+const CLOSE_STATUS_NAME_HINTS = new Set([
+  'done',
+  'closed',
+  'resolved',
+  'complete',
+  'completed',
+]);
+
+/**
+ * Prefer a transition whose target statusCategory.key is `done`, else a
+ * well-known Done/Closed/Resolved-like status name (case-insensitive).
+ * @param {Array<{
+ *   id?: string,
+ *   name?: string,
+ *   to?: { name?: string, statusCategory?: { key?: string, name?: string } },
+ * }>} transitions
+ * @returns {{ id: string, name?: string, to?: { name?: string } } | null}
+ */
+export function findCloseTransition(transitions) {
+  const list = Array.isArray(transitions) ? transitions : [];
+  for (const t of list) {
+    if (!t || t.id == null) continue;
+    const catKey = String(t.to?.statusCategory?.key || '')
+      .trim()
+      .toLowerCase();
+    if (catKey === 'done') {
+      return /** @type {{ id: string, name?: string, to?: { name?: string } }} */ (t);
+    }
+  }
+  for (const t of list) {
+    if (!t || t.id == null) continue;
+    const toName = String(t.to?.name || '')
+      .trim()
+      .toLowerCase();
+    if (toName && CLOSE_STATUS_NAME_HINTS.has(toName)) {
+      return /** @type {{ id: string, name?: string, to?: { name?: string } }} */ (t);
+    }
+  }
+  return null;
+}
+
+/**
+ * Add a label to a Jira issue (REST update `labels` add op).
+ * @param {string} key
+ * @param {string} label
+ * @param {{
+ *   baseUrl: string,
+ *   email: string,
+ *   apiToken: string,
+ *   fetchFn?: typeof fetch,
+ * }} creds
+ * @returns {Promise<{ ok: true, key: string, label: string }>}
+ */
+export async function addJiraIssueLabel(key, label, creds) {
+  const fetchFn = creds.fetchFn || fetch;
+  const base = normalizeJiraBaseUrl(creds.baseUrl);
+  const normalizedKey = String(key).toUpperCase();
+  const name = String(label || '').trim();
+  if (!name) {
+    throw new Error('Jira label name is required');
+  }
+
+  const headers = {
+    Authorization: jiraAuthHeader({
+      email: creds.email,
+      apiToken: creds.apiToken,
+    }),
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+  };
+
+  const url = `${base}/rest/api/3/issue/${encodeURIComponent(normalizedKey)}`;
+  const res = await fetchFn(url, {
+    method: 'PUT',
+    headers,
+    body: JSON.stringify({
+      update: {
+        labels: [{ add: name }],
+      },
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    const detail = body ? `: ${body.slice(0, 300)}` : '';
+    throw new Error(
+      `Failed to add Jira label "${name}" on ${normalizedKey} (${res.status} ${res.statusText})${detail}`
+    );
+  }
+
+  return { ok: true, key: normalizedKey, label: name };
+}
+
+/**
+ * Close a Jira issue by transitioning to a Done-category (or Done/Closed-like) status.
+ * There is no dedicated “close” REST endpoint; this reuses the transitions API.
+ * @param {string} key
+ * @param {{
+ *   baseUrl: string,
+ *   email: string,
+ *   apiToken: string,
+ *   fetchFn?: typeof fetch,
+ * }} creds
+ * @returns {Promise<{
+ *   ok: true,
+ *   key: string,
+ *   transitionId: string,
+ *   statusName: string,
+ * }>}
+ */
+export async function closeJiraIssue(key, creds) {
+  const fetchFn = creds.fetchFn || fetch;
+  const base = normalizeJiraBaseUrl(creds.baseUrl);
+  const normalizedKey = String(key).toUpperCase();
+
+  const headers = {
+    Authorization: jiraAuthHeader({
+      email: creds.email,
+      apiToken: creds.apiToken,
+    }),
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+  };
+
+  const listUrl = `${base}/rest/api/3/issue/${encodeURIComponent(normalizedKey)}/transitions`;
+  const listRes = await fetchFn(listUrl, { method: 'GET', headers });
+  if (!listRes.ok) {
+    const body = await listRes.text().catch(() => '');
+    const detail = body ? `: ${body.slice(0, 300)}` : '';
+    throw new Error(
+      `Failed to list Jira transitions for ${normalizedKey} (${listRes.status} ${listRes.statusText})${detail}`
+    );
+  }
+
+  const listData = await listRes.json();
+  const match = findCloseTransition(listData.transitions || []);
+  if (!match) {
+    const available = (listData.transitions || [])
+      .map((t) => t?.to?.name)
+      .filter(Boolean)
+      .join(', ');
+    throw new Error(
+      `No Jira close transition (Done/Closed-like status) for ${normalizedKey}` +
+        (available ? ` (available: ${available})` : '')
+    );
+  }
+
+  const postRes = await fetchFn(listUrl, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ transition: { id: String(match.id) } }),
+  });
+
+  if (!postRes.ok) {
+    const body = await postRes.text().catch(() => '');
+    const detail = body ? `: ${body.slice(0, 300)}` : '';
+    const statusName = match.to?.name || 'Done';
+    throw new Error(
+      `Failed to close Jira issue ${normalizedKey} via "${statusName}" (${postRes.status} ${postRes.statusText})${detail}`
+    );
+  }
+
+  return {
+    ok: true,
+    key: normalizedKey,
+    transitionId: String(match.id),
+    statusName: match.to?.name || 'Done',
+  };
+}

package/src/models.js

@@ -0,0 +1,366 @@
+/**
+ * Resolve Claude model options for the Settings UI.
+ *
+ * Prefer Anthropic Models API (`GET /v1/models`) when an API key, auth token,
+ * or Claude Code OAuth credential is available. Claude Agent SDK and Claude CLI
+ * do not expose a list endpoint. Subscription-only login without a readable
+ * credential falls back to a curated Claude Code / Agent SDK list.
+ */
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * Curated Claude Agent SDK / Claude Code model ids used as defaults + fallback.
+ * Prefer documented Code aliases and Anthropic API ids (not invented snapshots).
+ */
+export const MODEL_OPTIONS = [
+  { id: 'claude-sonnet-5', label: 'Sonnet 5' },
+  { id: 'claude-opus-5', label: 'Opus 5' },
+  { id: 'claude-fable-5', label: 'Fable 5' },
+  { id: 'claude-haiku-4-5', label: 'Haiku 4.5' },
+  { id: 'sonnet', label: 'sonnet (latest)' },
+  { id: 'opus', label: 'opus (latest)' },
+  { id: 'haiku', label: 'haiku (latest)' },
+  { id: 'fable', label: 'fable (latest)' },
+  { id: 'best', label: 'best' },
+  { id: 'opusplan', label: 'opusplan' },
+  { id: 'claude-sonnet-4-6', label: 'Sonnet 4.6' },
+  { id: 'claude-opus-4-8', label: 'Opus 4.8' },
+  { id: 'claude-opus-4-7', label: 'Opus 4.7' },
+  { id: 'claude-opus-4-6', label: 'Opus 4.6' },
+  { id: 'claude-sonnet-4-5', label: 'Sonnet 4.5' },
+  { id: 'claude-opus-4-5', label: 'Opus 4.5' },
+  { id: 'claude-haiku-4-5-20251001', label: 'Haiku 4.5 (20251001)' },
+  { id: 'claude-sonnet-4-5-20250929', label: 'Sonnet 4.5 (20250929)' },
+  { id: 'claude-opus-4-5-20251101', label: 'Opus 4.5 (20251101)' },
+];
+
+export const DEFAULT_MODEL = 'claude-sonnet-5';
+
+/** Loose model id shape accepted by config (API ids + Claude Code aliases). */
+export const MODEL_ID_RE = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+
+const ANTHROPIC_MODELS_URL = 'https://api.anthropic.com/v1/models';
+const ANTHROPIC_VERSION = '2023-06-01';
+const CACHE_TTL_MS = 5 * 60_000;
+const KEYCHAIN_SERVICE = 'Claude Code-credentials';
+
+/** @typedef {{ id: string, name?: string, label?: string }} ModelOption */
+/** @typedef {'anthropic' | 'fallback'} ModelsSource */
+/** @typedef {{ models: ModelOption[], selected: string, source: ModelsSource }} ModelsListResult */
+
+/** @type {{ expiresAt: number, result: Omit<ModelsListResult, 'selected'> } | null} */
+let cache = null;
+
+/** @type {typeof fetch | null} */
+let fetchImpl = null;
+
+/** @type {() => NodeJS.ProcessEnv} */
+let envResolver = () => process.env;
+
+/** @type {() => string | null} */
+let credentialsTokenResolver = defaultCredentialsTokenResolver;
+
+/** @param {typeof fetch} fn */
+export function _setFetchImpl(fn) {
+  fetchImpl = fn;
+}
+
+export function _resetFetchImpl() {
+  fetchImpl = null;
+}
+
+/** @param {() => NodeJS.ProcessEnv} fn */
+export function _setEnvResolver(fn) {
+  envResolver = fn;
+}
+
+export function _resetEnvResolver() {
+  envResolver = () => process.env;
+}
+
+/** @param {() => string | null} fn */
+export function _setCredentialsTokenResolver(fn) {
+  credentialsTokenResolver = fn;
+}
+
+export function _resetCredentialsTokenResolver() {
+  credentialsTokenResolver = defaultCredentialsTokenResolver;
+}
+
+export function _resetModelsCache() {
+  cache = null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {value is string}
+ */
+export function isValidModelId(value) {
+  return typeof value === 'string' && MODEL_ID_RE.test(value.trim());
+}
+
+/**
+ * @param {string} id
+ * @param {string} [displayName]
+ * @returns {ModelOption}
+ */
+function toOption(id, displayName) {
+  const name = (displayName || '').trim();
+  return name ? { id, name, label: name } : { id, label: id };
+}
+
+/**
+ * Merge curated options (stable order / aliases) with live Anthropic rows.
+ * Same ids keep curated position but prefer live display names.
+ * @param {ModelOption[]} curated
+ * @param {ModelOption[]} live
+ * @returns {ModelOption[]}
+ */
+function mergeModelLists(curated, live) {
+  const liveById = new Map();
+  for (const m of live) {
+    if (m?.id) liveById.set(m.id, m);
+  }
+  const seen = new Set();
+  /** @type {ModelOption[]} */
+  const out = [];
+  for (const m of curated) {
+    if (!m?.id || seen.has(m.id)) continue;
+    seen.add(m.id);
+    const liveHit = liveById.get(m.id);
+    if (liveHit) {
+      const label = liveHit.label || liveHit.name || m.label || m.id;
+      const name = liveHit.name || liveHit.label || m.name;
+      out.push(name ? { id: m.id, name, label } : { id: m.id, label });
+    } else {
+      out.push({ ...m });
+    }
+  }
+  for (const m of live) {
+    if (!m?.id || seen.has(m.id)) continue;
+    seen.add(m.id);
+    out.push({ ...m });
+  }
+  return out;
+}
+
+/**
+ * @param {ModelOption[]} models
+ * @param {string} selected
+ * @returns {ModelOption[]}
+ */
+function ensureSelected(models, selected) {
+  if (!selected || models.some((m) => m.id === selected)) return models;
+  return [toOption(selected), ...models];
+}
+
+/**
+ * Extract Claude Code OAuth access token from a credentials JSON blob.
+ * @param {string} raw
+ * @returns {string | null}
+ */
+export function parseClaudeCodeOauthAccessToken(raw) {
+  try {
+    const parsed = JSON.parse(String(raw || '').trim());
+    const tok = parsed?.claudeAiOauth?.accessToken;
+    if (typeof tok === 'string' && tok.trim()) return tok.trim();
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+/**
+ * Read plaintext Claude Code credentials file (`~/.claude/.credentials.json`
+ * or `$CLAUDE_CONFIG_DIR/.credentials.json`).
+ * @returns {string | null}
+ */
+function readClaudeCodeCredentialsFile() {
+  const env = envResolver();
+  /** @type {string[]} */
+  const dirs = [];
+  const configDir = (env.CLAUDE_CONFIG_DIR || '').trim();
+  if (configDir) dirs.push(configDir);
+  dirs.push(join(homedir(), '.claude'));
+
+  for (const dir of dirs) {
+    const path = join(dir, '.credentials.json');
+    try {
+      if (!existsSync(path)) continue;
+      const tok = parseClaudeCodeOauthAccessToken(readFileSync(path, 'utf8'));
+      if (tok) return tok;
+    } catch {
+      // ignore unreadable paths
+    }
+  }
+  return null;
+}
+
+/**
+ * Read Claude Code OAuth token from macOS Keychain (browser `claude auth login`).
+ * @returns {string | null}
+ */
+function readClaudeCodeKeychainToken() {
+  if (process.platform !== 'darwin') return null;
+  try {
+    const raw = execFileSync(
+      'security',
+      ['find-generic-password', '-s', KEYCHAIN_SERVICE, '-w'],
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }
+    );
+    return parseClaudeCodeOauthAccessToken(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Claude Code subscription OAuth token from local credential stores.
+ * @returns {string | null}
+ */
+function defaultCredentialsTokenResolver() {
+  return readClaudeCodeCredentialsFile() || readClaudeCodeKeychainToken();
+}
+
+/**
+ * Build auth headers for Anthropic Models API from env or Claude Code login.
+ * @returns {{ headers: Record<string, string>, auth: string } | null}
+ */
+function resolveAnthropicAuth() {
+  const env = envResolver();
+  const apiKey = (env.ANTHROPIC_API_KEY || '').trim();
+  if (apiKey) {
+    return {
+      auth: 'api-key',
+      headers: {
+        'x-api-key': apiKey,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+    };
+  }
+  const bearer = (
+    env.ANTHROPIC_AUTH_TOKEN ||
+    env.CLAUDE_CODE_OAUTH_TOKEN ||
+    ''
+  ).trim();
+  if (bearer) {
+    return {
+      auth: 'bearer',
+      headers: {
+        Authorization: `Bearer ${bearer}`,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+    };
+  }
+
+  const stored = (credentialsTokenResolver() || '').trim();
+  if (stored) {
+    return {
+      auth: 'claude-code-login',
+      headers: {
+        Authorization: `Bearer ${stored}`,
+        'anthropic-version': ANTHROPIC_VERSION,
+      },
+    };
+  }
+  return null;
+}
+
+/**
+ * @param {Response} res
+ * @returns {Promise<ModelOption[]>}
+ */
+async function parseModelsResponse(res) {
+  if (!res.ok) {
+    throw new Error(`Anthropic Models API HTTP ${res.status}`);
+  }
+  const body = await res.json();
+  const rows = Array.isArray(body?.data) ? body.data : [];
+  /** @type {ModelOption[]} */
+  const models = [];
+  for (const row of rows) {
+    const id = typeof row?.id === 'string' ? row.id.trim() : '';
+    if (!isValidModelId(id)) continue;
+    const display =
+      typeof row.display_name === 'string'
+        ? row.display_name
+        : typeof row.name === 'string'
+          ? row.name
+          : '';
+    models.push(toOption(id, display));
+  }
+  if (models.length === 0) {
+    throw new Error('Anthropic Models API returned no models');
+  }
+  return models;
+}
+
+/**
+ * Fetch live models from Anthropic (no cache).
+ * @returns {Promise<ModelOption[]>}
+ */
+export async function fetchAnthropicModels() {
+  const auth = resolveAnthropicAuth();
+  if (!auth) {
+    throw new Error('No Anthropic API credentials for models list');
+  }
+  const doFetch = fetchImpl || globalThis.fetch;
+  if (typeof doFetch !== 'function') {
+    throw new Error('fetch is not available');
+  }
+  const res = await doFetch(ANTHROPIC_MODELS_URL, {
+    method: 'GET',
+    headers: auth.headers,
+  });
+  return parseModelsResponse(res);
+}
+
+/**
+ * List models for the UI.
+ * @param {{ selected?: string, force?: boolean }} [opts]
+ * @returns {Promise<ModelsListResult>}
+ */
+export async function listModels(opts = {}) {
+  const selectedRaw = opts.selected;
+  const selected = isValidModelId(selectedRaw)
+    ? String(selectedRaw).trim()
+    : DEFAULT_MODEL;
+  const force = opts.force === true;
+  const now = Date.now();
+
+  if (!force && cache && cache.expiresAt > now) {
+    return {
+      ...cache.result,
+      models: ensureSelected(cache.result.models, selected),
+      selected,
+    };
+  }
+
+  try {
+    const live = await fetchAnthropicModels();
+    // Keep curated Claude Code aliases available alongside API ids.
+    const models = ensureSelected(
+      mergeModelLists(
+        MODEL_OPTIONS.map((m) => ({ ...m })),
+        live
+      ),
+      selected
+    );
+    const result = { models, source: /** @type {ModelsSource} */ ('anthropic') };
+    cache = { expiresAt: now + CACHE_TTL_MS, result };
+    return { ...result, selected };
+  } catch {
+    const models = ensureSelected(
+      MODEL_OPTIONS.map((m) => ({ ...m })),
+      selected
+    );
+    const result = { models, source: /** @type {ModelsSource} */ ('fallback') };
+    // Short cache on fallback so we retry Anthropic soon after auth is saved.
+    cache = { expiresAt: now + 30_000, result };
+    return { ...result, selected };
+  }
+}