@xera-ai/core 0.1.7 → 0.4.0

package/src/bin-internal/graph-record.ts

@@ -0,0 +1,243 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { appendEvents } from '../graph/store';
+import type {
+  EdgeDiscoveredPayload,
+  Event,
+  PomPromotedPayload,
+  RunClassifiedPayload,
+  RunCompletedPayload,
+  TicketFetchedPayload,
+} from '../graph/types';
+import { SCHEMA_VERSION } from '../graph/types';
+import { ulid } from '../graph/ulid';
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+function sha1(s: string): string {
+  return createHash('sha1').update(s).digest('hex');
+}
+function scenarioId(ticket: string, name: string): string {
+  return sha1(`${ticket}:${name.trim().toLowerCase().replace(/\s+/g, ' ')}`);
+}
+function pomId(filePath: string): string {
+  return sha1(basename(filePath));
+}
+function makeEvent<T extends Event['type']>(
+  actor: string,
+  type: T,
+  payload: Extract<Event, { type: T }>['payload'],
+): Event {
+  return {
+    event_id: ulid(),
+    schema_version: SCHEMA_VERSION,
+    ts: nowIso(),
+    actor,
+    type,
+    payload,
+  } as Event;
+}
+
+interface StoryFrontmatter {
+  ticketId: string;
+  summary: string;
+  storyHash: string;
+  acceptanceCriteria?: string[];
+  linked_issues?: Array<{
+    ticketId: string;
+    relation: 'blocks' | 'duplicates' | 'relates' | 'supersedes';
+  }>;
+}
+
+function readStoryFrontmatter(repoRoot: string, ticket: string): StoryFrontmatter | null {
+  const path = join(repoRoot, '.xera', ticket, 'story.md');
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, 'utf8');
+  const m = raw.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return null;
+  return parseYaml(m[1]!) as StoryFrontmatter;
+}
+
+function readGraphInput(repoRoot: string, ticket: string): { modifiesAreas: string[] } {
+  const path = join(repoRoot, '.xera', ticket, 'graph-input.json');
+  if (!existsSync(path)) return { modifiesAreas: [] };
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return { modifiesAreas: [] };
+  }
+}
+
+export async function recordFetch(repoRoot: string, ticket: string): Promise<number> {
+  const fm = readStoryFrontmatter(repoRoot, ticket);
+  if (!fm) {
+    console.error(`[graph-record fetch] story.md not found for ${ticket}`);
+    return 1;
+  }
+  const { modifiesAreas } = readGraphInput(repoRoot, ticket);
+  const events: Event[] = [];
+  const fetchedPayload: TicketFetchedPayload = {
+    ticketId: fm.ticketId,
+    summary: fm.summary,
+    ac: fm.acceptanceCriteria ?? [],
+    jiraLinks: fm.linked_issues ?? [],
+    storyHash: fm.storyHash,
+    modifiesAreas,
+  };
+  events.push(makeEvent('xera-fetch', 'ticket.fetched', fetchedPayload));
+  for (const link of fm.linked_issues ?? []) {
+    const p: EdgeDiscoveredPayload = {
+      kind: 'jira-linked',
+      from: fm.ticketId,
+      to: link.ticketId,
+      source: `jira:${link.relation}`,
+    };
+    events.push(makeEvent('xera-fetch', 'edge.discovered', p));
+  }
+  for (const area of modifiesAreas) {
+    const p: EdgeDiscoveredPayload = {
+      kind: 'modifies',
+      from: fm.ticketId,
+      to: area,
+      source: 'extract-areas',
+    };
+    events.push(makeEvent('xera-fetch', 'edge.discovered', p));
+  }
+  appendEvents(repoRoot, events, { skill: 'xera-fetch', ticketId: ticket });
+  return 0;
+}
+
+async function recordScript(repoRoot: string, ticket: string): Promise<number> {
+  const { recordScriptImpl } = await import('./graph-record-script');
+  return recordScriptImpl(repoRoot, ticket);
+}
+
+async function recordExec(repoRoot: string, ticket: string, runId: string): Promise<number> {
+  const reporterPath = join(repoRoot, '.xera', ticket, 'runs', runId, 'reporter.json');
+  if (!existsSync(reporterPath)) {
+    console.error(`[graph-record exec] reporter.json missing`);
+    return 1;
+  }
+  const data = JSON.parse(readFileSync(reporterPath, 'utf8')) as {
+    scenarios: Array<{ name: string; status: 'pass' | 'fail'; runtime: number; traceId?: string }>;
+  };
+  const events: Event[] = [];
+  for (const s of data.scenarios) {
+    const p: RunCompletedPayload = {
+      scenarioId: scenarioId(ticket, s.name),
+      ticketId: ticket,
+      runId,
+      status: s.status,
+      runtime: s.runtime,
+    };
+    if (s.traceId) p.traceId = s.traceId;
+    events.push(makeEvent('xera-exec', 'run.completed', p));
+  }
+  appendEvents(repoRoot, events, { skill: 'xera-exec', ticketId: ticket });
+  return 0;
+}
+
+async function recordClassify(repoRoot: string, ticket: string, runId: string): Promise<number> {
+  const classifyPath = join(repoRoot, '.xera', ticket, 'runs', runId, 'classifier-output.json');
+  if (!existsSync(classifyPath)) {
+    console.error(`[graph-record classify] classifier-output.json missing`);
+    return 1;
+  }
+  const data = JSON.parse(readFileSync(classifyPath, 'utf8')) as {
+    scenarios: Array<{ name: string; class: string; confidence: 'low' | 'medium' | 'high' }>;
+  };
+  const events: Event[] = [];
+  for (const s of data.scenarios) {
+    const p: RunClassifiedPayload = {
+      scenarioId: scenarioId(ticket, s.name),
+      runId,
+      classification: s.class as RunClassifiedPayload['classification'],
+      confidence: s.confidence,
+    };
+    events.push(makeEvent('xera-report', 'run.classified', p));
+  }
+  appendEvents(repoRoot, events, { skill: 'xera-report', ticketId: ticket });
+  return 0;
+}
+
+async function recordPromote(repoRoot: string, args: Map<string, string>): Promise<number> {
+  const from = args.get('--from');
+  const to = args.get('--to');
+  const pomIdArg = args.get('--pom-id');
+  if (!from || !to) {
+    console.error(`[graph-record promote] --from and --to required`);
+    return 1;
+  }
+  const id = pomIdArg ?? pomId(from);
+  const p: PomPromotedPayload = { pomId: id, fromPath: from, toPath: to };
+  const e = makeEvent('xera-promote', 'pom.promoted', p);
+  appendEvents(repoRoot, [e], { skill: 'xera-promote', ticketId: 'shared' });
+  return 0;
+}
+
+function parseFlags(args: string[]): Map<string, string> {
+  const m = new Map<string, string>();
+  for (let i = 0; i < args.length; i++) {
+    if (args[i]!.startsWith('--')) {
+      m.set(args[i]!, args[i + 1] ?? '');
+      i++;
+    }
+  }
+  return m;
+}
+
+export async function graphRecordCmd(argv: string[]): Promise<number> {
+  const [action, ...rest] = argv;
+  if (!action) {
+    console.error(`Usage: xera-internal graph-record <fetch|script|exec|classify|promote> [args]`);
+    return 1;
+  }
+  const repoRoot = process.cwd();
+  switch (action) {
+    case 'fetch': {
+      const ticket = rest[0];
+      if (!ticket) {
+        console.error('ticket required');
+        return 1;
+      }
+      return recordFetch(repoRoot, ticket);
+    }
+    case 'script': {
+      const ticket = rest[0];
+      if (!ticket) {
+        console.error('ticket required');
+        return 1;
+      }
+      return recordScript(repoRoot, ticket);
+    }
+    case 'exec': {
+      const ticket = rest[0];
+      const flags = parseFlags(rest);
+      const runId = flags.get('--run-id');
+      if (!ticket || !runId) {
+        console.error('ticket + --run-id required');
+        return 1;
+      }
+      return recordExec(repoRoot, ticket, runId);
+    }
+    case 'classify': {
+      const ticket = rest[0];
+      const flags = parseFlags(rest);
+      const runId = flags.get('--run-id');
+      if (!ticket || !runId) {
+        console.error('ticket + --run-id required');
+        return 1;
+      }
+      return recordClassify(repoRoot, ticket, runId);
+    }
+    case 'promote': {
+      return recordPromote(repoRoot, parseFlags(rest));
+    }
+    default:
+      console.error(`Unknown action: ${action}`);
+      return 1;
+  }
+}

package/src/bin-internal/graph-snapshot.ts

@@ -0,0 +1,23 @@
+import { deriveSnapshot, isSnapshotStale, loadAllEvents, writeSnapshot } from '../graph/store';
+
+export async function graphSnapshotCmd(argv: string[]): Promise<number> {
+  const check = argv.includes('--check');
+  const noRebuild = argv.includes('--no-rebuild');
+  const repoRoot = process.cwd();
+  const stale = isSnapshotStale(repoRoot);
+  if (check) {
+    if (!stale) return 0;
+    if (noRebuild) {
+      console.error('[graph-snapshot] stale');
+      return 1;
+    }
+    // fall through to rebuild
+  }
+  const events = loadAllEvents(repoRoot);
+  const snap = deriveSnapshot(events);
+  writeSnapshot(repoRoot, snap);
+  if (check && stale) {
+    console.log(`[graph-snapshot] rebuilt (${events.length} events)`);
+  }
+  return 0;
+}

package/src/bin-internal/heal-prepare.ts

@@ -0,0 +1,230 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { scrubFreeText } from '@xera-ai/web';
+import { unzipSync } from 'fflate';
+import { resolveArtifactPaths } from '../artifact/paths';
+
+export type FailedLocatorKind = 'role' | 'test-id' | 'css-class' | 'text' | 'label' | 'other';
+
+export interface HealInput {
+  ticket: string;
+  runId: string;
+  scenarioName: string;
+  failedLocator: {
+    raw: string;
+    kind: FailedLocatorKind;
+    pomFile: string;
+    pomLine: number;
+    pomLineContent: string;
+    pomMethodName: string;
+  };
+  gherkinStep: string;
+  domSnapshotAtFailure: string;
+}
+
+interface ClassifierInput {
+  runId: string;
+  scenarios: Array<{
+    name: string;
+    outcome: string;
+    class: string;
+    confidence: string;
+    rationale: string;
+  }>;
+}
+
+interface NormalizedRunFile {
+  runId: string;
+  scenarios: Array<{
+    name: string;
+    outcome: 'PASS' | 'FAIL' | 'SKIPPED';
+    failure?: { errorMessage?: string };
+  }>;
+}
+
+const LOCATOR_LINE_RE = /^Locator:\s*(.+)$/m;
+
+function classifyKind(raw: string): FailedLocatorKind {
+  if (/^getByRole\b/.test(raw)) return 'role';
+  if (/^getByTestId\b/.test(raw)) return 'test-id';
+  if (/^getByLabel\b/.test(raw)) return 'label';
+  if (/^getByText\b/.test(raw)) return 'text';
+  if (/^locator\(\s*['"`]\s*\.[A-Za-z_-]/.test(raw)) return 'css-class';
+  return 'other';
+}
+
+function extractDomSnapshot(tracePath: string): string {
+  if (!existsSync(tracePath)) return '';
+  const buf = readFileSync(tracePath);
+  const entries = unzipSync(buf);
+
+  // Strategy: parse the .trace JSONL event file to find the last frame-snapshot
+  // event, then extract the HTML resource it references. This gives us the DOM
+  // snapshot closest to the failure point rather than a lexicographic approximation.
+  // Falls back to last .html by lex sort if the .trace file is missing or unparseable.
+  const traceKey = Object.keys(entries).find((name) => name.endsWith('.trace'));
+  let chosenKey: string | null = null;
+
+  if (traceKey) {
+    const traceText = new TextDecoder().decode(entries[traceKey]!);
+    const lines = traceText.split('\n').filter(Boolean);
+    // Walk events in REVERSE order to find the most recent frame-snapshot.
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const evt = JSON.parse(lines[i]!);
+        const isSnapshot = evt.type === 'frame-snapshot' || evt.type === 'snapshot';
+        if (!isSnapshot) continue;
+        const snap = evt.snapshot ?? {};
+        // Try direct resource reference (older format).
+        const resourceName: unknown = snap.resourceName;
+        if (typeof resourceName === 'string') {
+          if (entries[resourceName]) {
+            chosenKey = resourceName;
+            break;
+          }
+          // Some traces store .html files under resources/ with the resourceName as the basename.
+          const guessed = `resources/${resourceName.replace(/^resources\//, '')}`;
+          if (entries[guessed]) {
+            chosenKey = guessed;
+            break;
+          }
+        }
+        // Try snapshot name → look for matching .html in resources/.
+        const snapshotName: unknown = snap.snapshotName;
+        if (typeof snapshotName === 'string') {
+          const directGuess = Object.keys(entries).find(
+            (k) => k.endsWith('.html') && k.includes(snapshotName),
+          );
+          if (directGuess) {
+            chosenKey = directGuess;
+            break;
+          }
+        }
+      } catch {
+        // Skip unparseable trace lines.
+      }
+    }
+  }
+
+  // Fallback: last .html by lexicographic sort (existing heuristic).
+  if (!chosenKey) {
+    const htmlKeys = Object.keys(entries)
+      .filter((name) => name.endsWith('.html'))
+      .sort();
+    chosenKey = htmlKeys[htmlKeys.length - 1] ?? null;
+  }
+
+  if (!chosenKey) return '';
+  const html = new TextDecoder().decode(entries[chosenKey]!);
+  return scrubFreeText(html);
+}
+
+function findPomLine(
+  ticketDir: string,
+  rawLocator: string,
+): { pomFile: string; pomLine: number; pomLineContent: string; pomMethodName: string } {
+  const pomDir = join(ticketDir, 'page-objects');
+  const candidates: string[] = [];
+  if (existsSync(pomDir)) {
+    for (const name of readdirSync(pomDir)) {
+      if (name.endsWith('.ts')) candidates.push(join(pomDir, name));
+    }
+  }
+  for (const file of candidates) {
+    const text = readFileSync(file, 'utf8');
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!;
+      if (line.includes(rawLocator)) {
+        const methodMatch = /^\s*(\w+)\s*=/.exec(line);
+        return {
+          pomFile: file,
+          pomLine: i + 1,
+          pomLineContent: line,
+          pomMethodName: methodMatch?.[1] ?? '<anonymous>',
+        };
+      }
+    }
+  }
+  throw new Error(`POM line not found for locator: ${rawLocator}`);
+}
+
+function findGherkinStep(featureText: string, rawLocator: string): string {
+  // Best-effort: find the first step line that mentions a quoted string
+  // appearing in the locator (e.g. a button name). Falls back to the
+  // first When/Then line if no match.
+  const quoteMatch = /['"`]([^'"`]{2,})['"`]/.exec(rawLocator);
+  if (quoteMatch) {
+    const needle = quoteMatch[1]!;
+    for (const line of featureText.split('\n')) {
+      if (line.includes(needle) && /^\s*(When|Then|And|Given)\b/.test(line)) {
+        return line.trim();
+      }
+    }
+  }
+  for (const line of featureText.split('\n')) {
+    if (/^\s*(When|Then)\b/.test(line)) return line.trim();
+  }
+  return '';
+}
+
+export function healPrepare(
+  repoRoot: string,
+  ticket: string,
+  runId: string,
+  scenarioName: string,
+): HealInput {
+  const paths = resolveArtifactPaths(repoRoot, ticket);
+  const classifierPath = join(paths.ticketDir, 'classifier-input.json');
+  const classifier: ClassifierInput = JSON.parse(readFileSync(classifierPath, 'utf8'));
+  const cls = classifier.scenarios.find((s) => s.name === scenarioName);
+  if (!cls) throw new Error(`scenario not found in classifier-input: "${scenarioName}"`);
+
+  const runDir = join(paths.runsDir, runId);
+  const normalized: NormalizedRunFile = JSON.parse(
+    readFileSync(join(runDir, 'normalized.json'), 'utf8'),
+  );
+  const normSc = normalized.scenarios.find((s) => s.name === scenarioName);
+  if (!normSc?.failure) throw new Error(`no failure recorded for scenario "${scenarioName}"`);
+  const errorMessage = normSc.failure.errorMessage ?? '';
+  const m = LOCATOR_LINE_RE.exec(errorMessage);
+  if (!m) throw new Error(`cannot extract locator from errorMessage: ${errorMessage.slice(0, 80)}`);
+  const raw = m[1]!.trim();
+  const kind = classifyKind(raw);
+
+  const pomLoc = findPomLine(paths.ticketDir, raw);
+
+  const featureText = readFileSync(paths.featurePath, 'utf8');
+  const gherkinStep = findGherkinStep(featureText, raw);
+
+  const domSnapshotAtFailure = extractDomSnapshot(join(runDir, 'trace.zip'));
+
+  return {
+    ticket,
+    runId,
+    scenarioName,
+    failedLocator: { raw, kind, ...pomLoc },
+    gherkinStep,
+    domSnapshotAtFailure,
+  };
+}
+
+export async function healPrepareCmd(argv: string[]): Promise<number> {
+  const [ticket, runId, ...scenarioParts] = argv;
+  if (!ticket || !runId || scenarioParts.length === 0) {
+    console.error('[xera:heal-prepare] usage: heal-prepare <TICKET> <RUN_ID> <SCENARIO_NAME>');
+    return 1;
+  }
+  const scenarioName = scenarioParts.join(' ');
+  try {
+    const result = healPrepare(process.cwd(), ticket, runId, scenarioName);
+    const paths = resolveArtifactPaths(process.cwd(), ticket);
+    const outPath = join(paths.runsDir, runId, 'heal-input.json');
+    writeFileSync(outPath, JSON.stringify(result, null, 2));
+    console.log(`[xera:heal-prepare] wrote ${outPath}`);
+    return 0;
+  } catch (err) {
+    console.error(`[xera:heal-prepare] ${(err as Error).message}`);
+    return 1;
+  }
+}

package/src/bin-internal/index.ts

@@ -1,33 +1,55 @@
+import { doctorCmd } from './doctor';
+import { evalDeterministicCmd } from './eval-deterministic';
+import { evalPrepareCmd } from './eval-prepare';
+import { evalReportCmd } from './eval-report';
+import { execCmd } from './exec';
 import { fetchCmd } from './fetch';
-import { validateFeatureCmd } from './validate-feature';
-import { typecheckCmd } from './typecheck';
+import { graphBackfillCmd } from './graph-backfill';
+import { graphQueryCmd } from './graph-query';
+import { graphRecordCmd } from './graph-record';
+import { graphSnapshotCmd } from './graph-snapshot';
+import { healPrepareCmd } from './heal-prepare';
 import { lintCmd } from './lint';
-import { execCmd } from './exec';
 import { normalizeCmd } from './normalize';
-import { reportCmd } from './report';
 import { postCmd } from './post';
+import { promoteCmd } from './promote';
+import { reportCmd } from './report';
 import { statusCmd } from './status-cmd';
+import { typecheckCmd } from './typecheck';
 import { unlockCmd } from './unlock';
-import { promoteCmd } from './promote';
+import { validateFeatureCmd } from './validate-feature';
+import { verifyPromptsCmd } from './verify-prompts';
 
 const COMMANDS: Record<string, (argv: string[]) => Promise<number>> = {
+  doctor: doctorCmd,
+  'eval-deterministic': evalDeterministicCmd,
+  'eval-prepare': evalPrepareCmd,
+  'eval-report': evalReportCmd,
+  exec: execCmd,
   fetch: fetchCmd,
-  'validate-feature': validateFeatureCmd,
-  typecheck: typecheckCmd,
+  'graph-backfill': graphBackfillCmd,
+  'graph-query': graphQueryCmd,
+  'graph-record': graphRecordCmd,
+  'graph-snapshot': graphSnapshotCmd,
+  'heal-prepare': healPrepareCmd,
   lint: lintCmd,
-  exec: execCmd,
   normalize: normalizeCmd,
-  report: reportCmd,
   post: postCmd,
+  promote: promoteCmd,
+  report: reportCmd,
   status: statusCmd,
+  typecheck: typecheckCmd,
   unlock: unlockCmd,
-  promote: promoteCmd,
+  'validate-feature': validateFeatureCmd,
+  'verify-prompts': verifyPromptsCmd,
 };
 
 export async function run(argv: string[]): Promise<number> {
   const [cmd, ...rest] = argv;
   if (!cmd || !COMMANDS[cmd]) {
-    console.error(`Usage: xera-internal <command> [args...]\nCommands: ${Object.keys(COMMANDS).join(', ')}`);
+    console.error(
+      `Usage: xera-internal <command> [args...]\nCommands: ${Object.keys(COMMANDS).join(', ')}`,
+    );
     return 1;
   }
   try {

package/src/bin-internal/lint.ts

@@ -1,12 +1,19 @@
-import { resolveArtifactPaths } from '../artifact/paths';
 import { lintTicket } from '@xera-ai/web';
+import { resolveArtifactPaths } from '../artifact/paths';
 
 export async function lintCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:lint] usage: lint <TICKET>'); return 1; }
+  if (!ticket) {
+    console.error('[xera:lint] usage: lint <TICKET>');
+    return 1;
+  }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
   const r = await lintTicket(paths.ticketDir);
-  if (r.ok) { console.log('[xera:lint] ok'); return 0; }
-  for (const w of r.warnings) console.error(`[xera:lint] ${w.file}:${w.line} [${w.rule}] ${w.message}`);
+  if (r.ok) {
+    console.log('[xera:lint] ok');
+    return 0;
+  }
+  for (const w of r.warnings)
+    console.error(`[xera:lint] ${w.file}:${w.line} [${w.rule}] ${w.message}`);
   return 2;
 }

package/src/bin-internal/normalize.ts

@@ -1,20 +1,34 @@
-import { resolveArtifactPaths } from '../artifact/paths';
-import { normalizeRun } from '@xera-ai/web';
-import { readdirSync, existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { normalizeRun } from '@xera-ai/web';
+import { resolveArtifactPaths } from '../artifact/paths';
 
 export async function normalizeCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:normalize] usage: normalize <TICKET> [--run=<runId>]'); return 1; }
+  if (!ticket) {
+    console.error('[xera:normalize] usage: normalize <TICKET> [--run=<runId>]');
+    return 1;
+  }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
-  const runArg = argv.find(a => a.startsWith('--run='));
+  const runArg = argv.find((a) => a.startsWith('--run='));
   const runId = runArg
     ? runArg.split('=')[1]!
-    : readdirSync(paths.runsDir).filter(n => !n.startsWith('.')).sort().pop()!;
-  if (!runId) { console.error('[xera:normalize] no run found'); return 1; }
+    : readdirSync(paths.runsDir)
+        .filter((n) => !n.startsWith('.'))
+        .sort()
+        .pop()!;
+  if (!runId) {
+    console.error('[xera:normalize] no run found');
+    return 1;
+  }
   const runDir = join(paths.runsDir, runId);
-  if (!existsSync(runDir)) { console.error(`[xera:normalize] runs/${runId} missing`); return 1; }
+  if (!existsSync(runDir)) {
+    console.error(`[xera:normalize] runs/${runId} missing`);
+    return 1;
+  }
   const r = await normalizeRun({ runId, runDir });
-  console.log(`[xera:normalize] wrote normalized.json (scrubbed_fields_count=${r.scrubbed_fields_count})`);
+  console.log(
+    `[xera:normalize] wrote normalized.json (scrubbed_fields_count=${r.scrubbed_fields_count})`,
+  );
   return 0;
 }

package/src/bin-internal/post.ts

@@ -1,13 +1,16 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolveArtifactPaths } from '../artifact/paths';
-import { loadConfig } from '../config/load';
 import { readStatus, writeStatus } from '../artifact/status';
+import { loadConfig } from '../config/load';
 import { createJiraClient } from '../jira/client';
 
 export async function postCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:post] usage: post <TICKET>'); return 1; }
+  if (!ticket) {
+    console.error('[xera:post] usage: post <TICKET>');
+    return 1;
+  }
   const cwd = process.cwd();
   const config = await loadConfig(cwd);
   if (!config.reporting.postToJira) {
@@ -16,7 +19,10 @@ export async function postCmd(argv: string[]): Promise<number> {
   }
   const paths = resolveArtifactPaths(cwd, ticket);
   const draftPath = join(paths.ticketDir, 'jira-comment.draft.md');
-  if (!existsSync(draftPath)) { console.error(`[xera:post] no draft at ${draftPath}; run \`xera-internal report\` first.`); return 1; }
+  if (!existsSync(draftPath)) {
+    console.error(`[xera:post] no draft at ${draftPath}; run \`xera-internal report\` first.`);
+    return 1;
+  }
   const body = readFileSync(draftPath, 'utf8');
 
   const client = await createJiraClient({

package/src/bin-internal/report.ts

@@ -2,9 +2,9 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolveArtifactPaths } from '../artifact/paths';
 import { aggregateScenarios } from '../classifier/aggregate';
-import { writeStatusFromClassification } from '../reporter/status-writer';
-import { buildJiraComment } from '../reporter/jira-comment';
 import type { ScenarioClassification } from '../classifier/types';
+import { buildJiraComment } from '../reporter/jira-comment';
+import { writeStatusFromClassification } from '../reporter/status-writer';
 
 interface ReportInput {
   scenarios: ScenarioClassification[];
@@ -14,7 +14,7 @@ interface ReportInput {
 
 export async function reportCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  const inputArg = argv.find(a => a.startsWith('--input='));
+  const inputArg = argv.find((a) => a.startsWith('--input='));
   if (!ticket || !inputArg) {
     console.error('[xera:report] usage: report <TICKET> --input=<classifier-output.json>');
     return 1;