@xera-ai/core 0.1.4 → 0.1.6

package/src/jira/rest-backend.ts

@@ -0,0 +1,79 @@
+import type { JiraClient, JiraFieldMap, JiraTicket } from './types';
+
+interface RestCreds { email: string; apiToken: string; }
+
+export function createRestBackend(baseUrl: string, creds: RestCreds): JiraClient {
+  const authHeader = `Basic ${Buffer.from(`${creds.email}:${creds.apiToken}`).toString('base64')}`;
+  const base = baseUrl.replace(/\/$/, '');
+
+  async function req(path: string, init?: RequestInit): Promise<Response> {
+    const r = await fetch(`${base}${path}`, {
+      ...init,
+      headers: {
+        Authorization: authHeader,
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        ...(init?.headers ?? {}),
+      },
+    });
+    if (!r.ok && r.status !== 201) {
+      throw new Error(`Jira REST ${init?.method ?? 'GET'} ${path} failed: ${r.status} ${await r.text()}`);
+    }
+    return r;
+  }
+
+  return {
+    backend: 'rest',
+    async fetchTicket(key, fields): Promise<JiraTicket> {
+      const want = ['summary', fields.story];
+      if (fields.acceptanceCriteria) want.push(fields.acceptanceCriteria);
+      want.push('attachment');
+      const r = await req(`/rest/api/3/issue/${encodeURIComponent(key)}?fields=${want.join(',')}`);
+      const json = (await r.json()) as { key: string; fields: Record<string, unknown> };
+      const f = json.fields;
+      const attachments = Array.isArray(f.attachment)
+        ? (f.attachment as Array<{ filename: string; content: string }>).map(a => ({ filename: a.filename, url: a.content }))
+        : [];
+      const ticket: JiraTicket = {
+        key: json.key,
+        summary: String(f.summary ?? ''),
+        story: String(f[fields.story] ?? ''),
+        attachments,
+        raw: f,
+      };
+      if (fields.acceptanceCriteria) {
+        ticket.acceptanceCriteria = String(f[fields.acceptanceCriteria] ?? '');
+      }
+      return ticket;
+    },
+    async postComment(key, body) {
+      const r = await req(`/rest/api/3/issue/${encodeURIComponent(key)}/comment`, {
+        method: 'POST',
+        body: JSON.stringify({
+          body: { type: 'doc', version: 1, content: [{ type: 'paragraph', content: [{ type: 'text', text: body }] }] },
+        }),
+      });
+      const json = (await r.json()) as { id: string };
+      return { id: json.id };
+    },
+    async transitionStatus(key, statusName) {
+      const tr = await req(`/rest/api/3/issue/${encodeURIComponent(key)}/transitions`);
+      const json = (await tr.json()) as { transitions: Array<{ id: string; name: string }> };
+      const t = json.transitions.find(x => x.name === statusName);
+      if (!t) throw new Error(`No transition named "${statusName}" available for ${key}`);
+      await req(`/rest/api/3/issue/${encodeURIComponent(key)}/transitions`, {
+        method: 'POST',
+        body: JSON.stringify({ transition: { id: t.id } }),
+      });
+    },
+    async listFields(sampleKey) {
+      const r = await req(`/rest/api/3/issue/${encodeURIComponent(sampleKey)}?fields=*all`);
+      const json = (await r.json()) as { fields: Record<string, unknown> };
+      return Object.entries(json.fields).map(([id, value]) => ({
+        id,
+        name: id,
+        hasContent: value !== null && value !== undefined && value !== '',
+      }));
+    },
+  };
+}

package/src/jira/retry.ts

@@ -0,0 +1,24 @@
+export interface RetryOptions {
+  maxAttempts: number;
+  baseMs: number;
+  factor: number;
+  shouldRetry?: (err: unknown) => boolean;
+}
+
+export async function withRetry<T>(fn: () => Promise<T>, opts: RetryOptions): Promise<T> {
+  let attempt = 0;
+  let lastErr: unknown;
+  while (attempt < opts.maxAttempts) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (opts.shouldRetry && !opts.shouldRetry(err)) throw err;
+      attempt++;
+      if (attempt >= opts.maxAttempts) break;
+      const delay = opts.baseMs * Math.pow(opts.factor, attempt - 1);
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
+  throw lastErr;
+}

package/src/jira/types.ts

@@ -0,0 +1,21 @@
+export interface JiraTicket {
+  key: string;
+  summary: string;
+  story: string;
+  acceptanceCriteria?: string;
+  attachments: Array<{ filename: string; url: string }>;
+  raw: Record<string, unknown>;
+}
+
+export interface JiraFieldMap {
+  story: string;
+  acceptanceCriteria?: string;
+}
+
+export interface JiraClient {
+  readonly backend: 'mcp' | 'rest';
+  fetchTicket(key: string, fields: JiraFieldMap): Promise<JiraTicket>;
+  postComment(key: string, body: string): Promise<{ id: string }>;
+  transitionStatus(key: string, statusName: string): Promise<void>;
+  listFields(sampleKey: string): Promise<Array<{ id: string; name: string; hasContent: boolean }>>;
+}

package/src/lock/file-lock.ts

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { hostname } from 'node:os';
+
+export interface LockData {
+  pid: number;
+  hostname: string;
+  started_at: string;
+  run_id: string;
+}
+
+export function acquireLock(path: string, runId: string): boolean {
+  if (existsSync(path)) return false;
+  mkdirSync(dirname(path), { recursive: true });
+  const data: LockData = {
+    pid: process.pid,
+    hostname: hostname(),
+    started_at: new Date().toISOString(),
+    run_id: runId,
+  };
+  // Use 'wx' flag for atomic-ish create-only.
+  try {
+    writeFileSync(path, JSON.stringify(data), { flag: 'wx' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function releaseLock(path: string): void {
+  if (existsSync(path)) unlinkSync(path);
+}
+
+export function readLock(path: string): LockData | null {
+  if (!existsSync(path)) return null;
+  return JSON.parse(readFileSync(path, 'utf8')) as LockData;
+}
+
+export function isLockStale(path: string): boolean {
+  const lock = readLock(path);
+  if (!lock) return true;
+  if (lock.hostname !== hostname()) {
+    // Cannot verify a remote PID; treat as not stale.
+    return false;
+  }
+  try {
+    // Signal 0 = "check if process exists". Throws if not.
+    process.kill(lock.pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+export function forceUnlock(path: string): void {
+  releaseLock(path);
+}

package/src/logging/ndjson-logger.ts

@@ -0,0 +1,25 @@
+import { appendFileSync, mkdirSync, existsSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+export interface LogEntry {
+  ts: string;
+  [key: string]: unknown;
+}
+
+export class NdjsonLogger {
+  constructor(private readonly path: string) {
+    mkdirSync(dirname(path), { recursive: true });
+  }
+
+  log(payload: Record<string, unknown>): void {
+    const entry: LogEntry = { ts: new Date().toISOString(), ...payload };
+    appendFileSync(this.path, `${JSON.stringify(entry)}\n`);
+  }
+
+  static readAll(path: string): LogEntry[] {
+    if (!existsSync(path)) return [];
+    const txt = readFileSync(path, 'utf8').trim();
+    if (!txt) return [];
+    return txt.split('\n').map(line => JSON.parse(line) as LogEntry);
+  }
+}

package/src/reporter/jira-comment.ts

@@ -0,0 +1,31 @@
+import type { ClassifyOutput } from '../classifier/types';
+
+export interface JiraCommentInput extends ClassifyOutput {
+  ticket: string;
+  runId: string;
+  xeraVersion: string;
+  promptsVersion: string;
+}
+
+export function buildJiraComment(input: JiraCommentInput): string {
+  const passed = input.scenarios.filter(s => s.outcome === 'PASS').length;
+  const total = input.scenarios.length;
+  const icon = input.overall === 'PASS' ? '🟢' : '🔴';
+  const header = `## ${icon} xera test ${input.overall === 'PASS' ? 'PASSED' : 'FAILED'} — ${input.ticket} (run ${input.runId})`;
+  const meta = `**Classification:** ${input.overall} (confidence: ${input.overallConfidence})\n**Scenarios:** ${passed} / ${total} passed`;
+
+  const failingBlocks = input.scenarios
+    .filter(s => s.outcome === 'FAIL')
+    .map(s => `### Scenario: ${s.name}\n- **Classification:** ${s.class} (confidence: ${s.confidence})\n- **Diagnosis:** ${s.rationale}`)
+    .join('\n\n');
+
+  const reproduce = `### Reproduce locally\n\n\`\`\`\nbunx xera-internal exec ${input.ticket} --replay=${input.runId}\n\`\`\``;
+
+  const next = input.overall === 'PASS'
+    ? ''
+    : `### Suggested next action\n- Review the failing scenarios above.\n- Re-run after changes: open Claude Code and run \`/xera-run ${input.ticket}\`.\n\n`;
+
+  const footer = `---\nxera v${input.xeraVersion} • prompts v${input.promptsVersion}`;
+
+  return [header, '', meta, '', failingBlocks, '', next, reproduce, '', footer].filter(Boolean).join('\n');
+}

package/src/reporter/status-writer.ts

@@ -0,0 +1,37 @@
+import type { ClassifyOutput } from '../classifier/types';
+import { existsSync } from 'node:fs';
+import { readStatus, writeStatus, appendHistory, type StatusJson } from '../artifact/status';
+
+export interface StatusWriterInput {
+  ticket: string;
+  runTs: string;
+  classification: ClassifyOutput;
+  scenarioCounts: { total: number; passed: number; failed: number; skipped: number };
+}
+
+export function writeStatusFromClassification(path: string, input: StatusWriterInput): void {
+  const result: StatusJson['result'] = input.classification.overall === 'PASS' ? 'PASS' : 'FAIL';
+  const entry = { ts: input.runTs, result, class: input.classification.overall };
+  if (!existsSync(path)) {
+    writeStatus(path, {
+      ticket: input.ticket,
+      lastRun: input.runTs,
+      result,
+      classification: input.classification.overall,
+      confidence: input.classification.overallConfidence,
+      scenarios: input.scenarioCounts,
+      history: [entry],
+    });
+    return;
+  }
+  const cur = readStatus(path)!;
+  writeStatus(path, {
+    ...cur,
+    lastRun: input.runTs,
+    result,
+    classification: input.classification.overall,
+    confidence: input.classification.overallConfidence,
+    scenarios: input.scenarioCounts,
+  });
+  appendHistory(path, entry);
+}