@sun-asterisk/sungen 2.4.5 → 2.4.6

package/src/exporters/csv-exporter.ts

@@ -0,0 +1,304 @@
+/**
+ * Assemble CSV rows from merged scenarios + test data + playwright results.
+ * Outputs a CSV file matching the BM-2-901-13 test case template format.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { getPackageVersion } from './package-info';
+import { MergedScenario } from './scenario-merger';
+import {
+  extractAuthRole,
+  extractPriority,
+  extractTestcaseType,
+  generateTcId,
+  mapVpToCategory2,
+  splitVpAndName,
+} from './feature-parser';
+import { formatNumberedSteps, formatPrecondition, cleanStepLine } from './step-formatter';
+import { formatTestData } from './test-data-resolver';
+import {
+  formatExecutedDate,
+  formatNote,
+  statusToTestResult,
+} from './playwright-report-parser';
+import { EnvironmentInfo, PlaywrightResult, ScreenSummary, TestCaseRow } from './types';
+
+export interface BuildCsvInput {
+  screen: string;
+  featureName: string;
+  merged: MergedScenario[];
+  testData: Record<string, string>;
+  results: Map<string, PlaywrightResult> | null;
+  env: EnvironmentInfo;
+}
+
+/**
+ * Build CSV test case rows from merged scenarios.
+ */
+export function buildTestCaseRows(input: BuildCsvInput): TestCaseRow[] {
+  const rows: TestCaseRow[] = [];
+  let fallbackIndex = 1;
+
+  for (const m of input.merged) {
+    const { vpId, category1 } = splitVpAndName(m.feature.name);
+    const tcId = generateTcId(input.screen, vpId, fallbackIndex);
+    if (!vpId) fallbackIndex++;
+
+    const category2 = mapVpToCategory2(vpId);
+    const priority = extractPriority(m.feature.tags);
+    const testcaseType = extractTestcaseType(m.feature.tags);
+    const authRole = extractAuthRole(m.feature.tags);
+
+    // Prefer .spec.ts resolved comments for Steps/Expected if available
+    let steps: string;
+    let expectedResults: string;
+    let precondition: string;
+
+    if (m.spec) {
+      precondition = formatPrecondition(authRole, m.spec.precondition);
+      steps = formatNumberedSteps(m.spec.steps);
+      expectedResults = formatNumberedSteps(m.spec.expectations);
+    } else {
+      // Fallback to .feature raw steps
+      precondition = formatPrecondition(authRole, m.feature.rawGivenSteps);
+      steps = formatNumberedSteps(m.feature.rawWhenSteps);
+      expectedResults = formatNumberedSteps(m.feature.rawThenSteps);
+    }
+
+    const testData = formatTestData(m.feature.referencedVars, input.testData);
+
+    // Match Playwright result by test title (from .spec.ts) OR by scenarioName
+    let result: PlaywrightResult | undefined;
+    if (input.results && m.spec) {
+      result = input.results.get(m.spec.testTitle);
+    }
+
+    // Determine Test Result
+    let testResult: string;
+    let executedDate = '';
+    let note = '';
+    let environment = '';
+    let executor = '';
+
+    if (!m.spec) {
+      // Scenario not compiled → Manual if @manual, else Not compiled
+      testResult = testcaseType === 'Manual' ? 'Pending' : 'N/A';
+      if (testcaseType !== 'Manual') {
+        note = 'Scenario not compiled — re-run `sungen generate --screen ' + input.screen + '`';
+      }
+    } else if (!result) {
+      // Compiled but no execution record → Pending
+      testResult = 'Pending';
+    } else {
+      testResult = statusToTestResult(result.status);
+      executedDate = formatExecutedDate(result.startTime);
+      note = formatNote(result);
+      environment = `${input.env.baseURL} (${input.env.projectName})`;
+      executor = input.env.executor;
+    }
+
+    // If we have environment info and the test actually ran, populate env + executor
+    if (testResult !== 'Pending' && testResult !== 'N/A') {
+      if (!environment) environment = `${input.env.baseURL} (${input.env.projectName})`;
+      if (!executor) executor = input.env.executor;
+    }
+
+    rows.push({
+      tcId,
+      category1,
+      category2,
+      category3: input.featureName,
+      category4: input.screen,
+      precondition,
+      testData,
+      steps,
+      expectedResults,
+      priority,
+      testcaseType: m.spec ? testcaseType : testcaseType === 'Manual' ? 'Manual' : 'Not compiled',
+      testResult,
+      executedDate,
+      testExecutor: executor,
+      testEnvironment: environment,
+      note,
+    });
+  }
+
+  return rows;
+}
+
+/**
+ * Calculate summary statistics from rows.
+ */
+export function buildSummary(screen: string, rows: TestCaseRow[], outputFile: string): ScreenSummary {
+  const summary: ScreenSummary = {
+    screen,
+    total: rows.length,
+    passed: 0,
+    failed: 0,
+    pending: 0,
+    na: 0,
+    notCompiled: 0,
+    outputFile,
+  };
+  for (const r of rows) {
+    if (r.testResult === 'Passed') summary.passed++;
+    else if (r.testResult === 'Failed') summary.failed++;
+    else if (r.testResult === 'Pending') summary.pending++;
+    else if (r.testResult === 'N/A') summary.na++;
+    if (r.testcaseType === 'Not compiled') summary.notCompiled++;
+  }
+  return summary;
+}
+
+// ----------------------------------------------------------------------------
+// CSV writer
+// ----------------------------------------------------------------------------
+
+/**
+ * Escape a CSV cell per RFC 4180.
+ * Wrap in quotes if contains: comma, newline, quote. Escape embedded " as "".
+ */
+function csvCell(v: string | number | undefined | null): string {
+  if (v === null || v === undefined) return '';
+  const s = String(v);
+  if (/[",\n\r]/.test(s)) {
+    return '"' + s.replace(/"/g, '""') + '"';
+  }
+  return s;
+}
+
+function csvRow(cells: Array<string | number | undefined | null>): string {
+  return cells.map(csvCell).join(',');
+}
+
+/**
+ * Compose the full CSV file content matching the BM-2-901-13 template.
+ */
+export function renderCsv(summary: ScreenSummary, rows: TestCaseRow[], specLink: string): string {
+  const issueDate = (() => {
+    const d = new Date();
+    return `${String(d.getDate()).padStart(2, '0')}/${String(d.getMonth() + 1).padStart(2, '0')}/${d.getFullYear()}`;
+  })();
+
+  const total = summary.total || 1; // avoid div by zero
+  const pct = (n: number) => `${Math.round((n / total) * 100)}%`;
+
+  // UTF-8 BOM for Excel compatibility with Vietnamese
+  const BOM = '\ufeff';
+  const lines: string[] = [];
+
+  // Header metadata block (mirrors sample)
+  const titleLabel = `${summary.screen.toUpperCase()} TESTCASE`;
+  lines.push(csvRow(['', '', '', titleLabel, '', '', 'No: BM-2-901-13', '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', '', '', '', '', `Version: ${getPackageVersion()}`, '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', '', '', '', '', `Issue Date: ${issueDate}`, '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['SUN ASTERISK VIETNAM CO., LTD', '', '', '', '', '', 'ISO/IEC 27001:2022 & ISO 9001:2015', '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', 'Total TCs', 'Passed', 'Failed', 'Pending', 'N/A', 'Remaining', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', summary.total, summary.passed, summary.failed, summary.pending, summary.na, summary.pending + summary.na, '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', '', pct(summary.passed), pct(summary.failed), pct(summary.pending), pct(summary.na), pct(summary.pending + summary.na), '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['Spec/Design link:', specLink, '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow(['*: Mandatory', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
+  lines.push(csvRow([
+    'TC ID*',
+    '{Category 1}',
+    '{Category 2}',
+    '{Category 3}',
+    '{Category 4}',
+    'Pre-condition',
+    'Test Data',
+    'Steps*',
+    'Expected results*',
+    'Priority',
+    'Testcase type',
+    'Test Result*',
+    'Executed Date*',
+    'Test Executor*',
+    'Test Environment',
+    'Note\n(Test evidence, DefectID, Actual result)',
+  ]));
+
+  // Group rows by Category 2 (in stable order)
+  const order = ['Accessing', 'GUI', 'Function'];
+  const grouped = new Map<string, TestCaseRow[]>();
+  for (const row of rows) {
+    const g = grouped.get(row.category2) || [];
+    g.push(row);
+    grouped.set(row.category2, g);
+  }
+  const emittedGroups = new Set<string>();
+  for (const group of order) {
+    const groupRows = grouped.get(group);
+    if (!groupRows || groupRows.length === 0) continue;
+    emittedGroups.add(group);
+    // Section header row (empty Category 1, group name in Category 2 column? sample puts it differently — empty row then category marker)
+    lines.push(csvRow(['', group, '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
+    for (const row of groupRows) {
+      lines.push(csvRow([
+        row.tcId,
+        row.category1,
+        '',
+        '',
+        '',
+        row.precondition,
+        row.testData,
+        row.steps,
+        row.expectedResults,
+        row.priority,
+        row.testcaseType,
+        row.testResult,
+        row.executedDate,
+        row.testExecutor,
+        row.testEnvironment,
+        row.note,
+      ]));
+    }
+  }
+  // Emit any groups not in the predefined order
+  for (const [group, groupRows] of grouped.entries()) {
+    if (emittedGroups.has(group)) continue;
+    lines.push(csvRow(['', group, '', '', '', '', '', '', '', '', '', '', '', '', '', '']));
+    for (const row of groupRows) {
+      lines.push(csvRow([
+        row.tcId,
+        row.category1,
+        '',
+        '',
+        '',
+        row.precondition,
+        row.testData,
+        row.steps,
+        row.expectedResults,
+        row.priority,
+        row.testcaseType,
+        row.testResult,
+        row.executedDate,
+        row.testExecutor,
+        row.testEnvironment,
+        row.note,
+      ]));
+    }
+  }
+
+  return BOM + lines.join('\n') + '\n';
+}
+
+/**
+ * Write the CSV to disk at qa/deliverables/<screen>-testcases.csv.
+ * Creates directory if needed.
+ */
+export function writeCsv(cwd: string, screen: string, csvContent: string): string {
+  const outDir = path.join(cwd, 'qa', 'deliverables');
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+  const outPath = path.join(outDir, `${screen}-testcases.csv`);
+  fs.writeFileSync(outPath, csvContent, 'utf-8');
+  return outPath;
+}
+
+// mark unused import to silence TS if needed
+void cleanStepLine;

package/src/exporters/feature-parser.ts

@@ -0,0 +1,168 @@
+/**
+ * Parse .feature files to extract scenario metadata for CSV export.
+ * Reuses the existing GherkinParser.
+ */
+
+import { GherkinParser, ParsedFeature, ParsedScenario } from '../generators/gherkin-parser';
+import { FeatureMetadata, ScenarioMetadata } from './types';
+
+/**
+ * Variables referenced in a scenario: find all {{var_name}} in step text.
+ */
+function extractReferencedVars(scenario: ParsedScenario): string[] {
+  const vars = new Set<string>();
+  for (const step of scenario.steps) {
+    const matches = step.text.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g);
+    for (const match of matches) {
+      vars.add(match[1]);
+    }
+    // Also check inline DataTable cells
+    if (step.dataTable) {
+      for (const row of step.dataTable.rows) {
+        for (const cell of row.cells) {
+          const cellMatches = cell.matchAll(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g);
+          for (const match of cellMatches) {
+            vars.add(match[1]);
+          }
+        }
+      }
+    }
+  }
+  return Array.from(vars);
+}
+
+/**
+ * Classify each step into Given / When / Then bucket based on its preceding
+ * explicit keyword. "And" inherits from the previous explicit keyword.
+ */
+function classifySteps(scenario: ParsedScenario): { given: string[]; when: string[]; then: string[] } {
+  const given: string[] = [];
+  const when: string[] = [];
+  const then: string[] = [];
+  let currentBucket: 'given' | 'when' | 'then' = 'given';
+
+  for (const step of scenario.steps) {
+    const keyword = step.keyword.trim();
+    if (keyword === 'Given') currentBucket = 'given';
+    else if (keyword === 'When') currentBucket = 'when';
+    else if (keyword === 'Then') currentBucket = 'then';
+    // And / But → inherit currentBucket
+
+    if (currentBucket === 'given') given.push(step.text);
+    else if (currentBucket === 'when') when.push(step.text);
+    else then.push(step.text);
+  }
+
+  return { given, when, then };
+}
+
+/**
+ * Parse .feature file → structured metadata ready for CSV assembly.
+ */
+export function parseFeatureMetadata(featureFilePath: string): FeatureMetadata {
+  const parser = new GherkinParser();
+  const parsed: ParsedFeature = parser.parseFeatureFile(featureFilePath);
+
+  const scenarios: ScenarioMetadata[] = parsed.scenarios.map((sc) => {
+    const { given, when, then } = classifySteps(sc);
+
+    return {
+      name: sc.name,
+      tags: [...parsed.tags, ...sc.tags],
+      stepsName: sc.stepsName,
+      extendsName: sc.extendsName,
+      referencedVars: extractReferencedVars(sc),
+      rawGivenSteps: given,
+      rawWhenSteps: when,
+      rawThenSteps: then,
+    };
+  });
+
+  return {
+    featureName: parsed.name,
+    featurePath: parsed.path,
+    featureTags: parsed.tags,
+    scenarios,
+  };
+}
+
+/**
+ * Return true if this scenario is a @steps:<name> base scenario that should
+ * be excluded from the CSV (it's only used for @extend inheritance).
+ */
+export function isStepsBaseScenario(sc: ScenarioMetadata): boolean {
+  return !!sc.stepsName;
+}
+
+/**
+ * Return true if this is the default scaffold sample scenario (not real).
+ */
+export function isSampleScaffoldScenario(sc: ScenarioMetadata): boolean {
+  return /^Sample scenario for /i.test(sc.name);
+}
+
+/**
+ * Extract priority from scenario tags.
+ */
+export function extractPriority(tags: string[]): string {
+  if (tags.includes('@critical')) return 'Critical';
+  if (tags.includes('@high')) return 'High';
+  if (tags.includes('@normal')) return 'Normal';
+  if (tags.includes('@low')) return 'Low';
+  return 'Normal';
+}
+
+/**
+ * Extract testcase type from scenario tags.
+ */
+export function extractTestcaseType(tags: string[]): 'Auto' | 'Manual' {
+  return tags.includes('@manual') ? 'Manual' : 'Auto';
+}
+
+/**
+ * Extract auth role from tags. Returns 'no-auth' if @no-auth, else role name or null.
+ */
+export function extractAuthRole(tags: string[]): string | null {
+  if (tags.includes('@no-auth')) return 'no-auth';
+  const authTag = tags.find((t) => t.startsWith('@auth:'));
+  if (authTag) return authTag.replace('@auth:', '');
+  return null;
+}
+
+/**
+ * Extract VP ID and human-readable name from scenario name like
+ * "VP-UI-001 Modal displays all required fields" →
+ *   { vpId: "VP-UI-001", category1: "Modal displays all required fields" }
+ */
+export function splitVpAndName(scenarioName: string): { vpId?: string; category1: string } {
+  const match = scenarioName.match(/^(VP-[A-Z]+-\d+[a-zA-Z]?)\s+(.+)$/);
+  if (match) {
+    return { vpId: match[1], category1: match[2] };
+  }
+  return { category1: scenarioName };
+}
+
+/**
+ * Map VP prefix to Category 2.
+ */
+export function mapVpToCategory2(vpId: string | undefined): string {
+  if (!vpId) return 'Function';
+  if (vpId.startsWith('VP-SEC-')) return 'Accessing';
+  if (vpId.startsWith('VP-UI-')) return 'GUI';
+  if (vpId.startsWith('VP-VAL-')) return 'Function';
+  if (vpId.startsWith('VP-LOGIC-')) return 'Function';
+  return 'Function';
+}
+
+/**
+ * Generate TC ID: <SCREEN_UPPER>-<VP-part>-<NNN> OR <SCREEN_UPPER>-<NNN> if no VP.
+ */
+export function generateTcId(screen: string, vpId: string | undefined, fallbackIndex: number): string {
+  const screenUpper = screen.toUpperCase().replace(/[^A-Z0-9]/g, '-');
+  if (vpId) {
+    // VP-UI-001 → UI-001
+    const vpPart = vpId.replace(/^VP-/, '');
+    return `${screenUpper}-${vpPart}`;
+  }
+  return `${screenUpper}-${String(fallbackIndex).padStart(3, '0')}`;
+}

package/src/exporters/package-info.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+let cached: string | null = null;
+
+/**
+ * Read `version` from the sungen package.json at module-root so the delivery
+ * report always reflects the installed CLI version instead of a hardcoded
+ * string. The lookup walks up from __dirname (works under both src/ via ts-node
+ * and dist/ after compilation) until a package.json with a `name` starting
+ * with `@sun-asterisk/sungen` or `sungen` is found.
+ */
+export function getPackageVersion(): string {
+  if (cached) return cached;
+  let dir = __dirname;
+  for (let i = 0; i < 6; i++) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (pkg && typeof pkg.version === 'string') {
+          cached = pkg.version;
+          return cached;
+        }
+      } catch {
+        // ignore and keep walking
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  cached = 'unknown';
+  return cached;
+}

package/src/exporters/playwright-report-parser.ts

@@ -0,0 +1,168 @@
+/**
+ * Parse Playwright results.json (JSON reporter output) to map test titles → execution status.
+ */
+
+import * as fs from 'fs';
+import { PlaywrightResult } from './types';
+
+/**
+ * Shape of the JSON reporter output we care about.
+ * See https://playwright.dev/docs/test-reporters#json-reporter
+ */
+interface PlaywrightJsonReport {
+  config?: { projects?: Array<{ name?: string }> };
+  suites?: PlaywrightSuite[];
+}
+
+interface PlaywrightSuite {
+  title?: string;
+  suites?: PlaywrightSuite[];
+  specs?: PlaywrightSpec[];
+}
+
+interface PlaywrightSpec {
+  title?: string;                // scenario title
+  tests?: Array<{
+    results?: Array<{
+      status?: string;           // 'passed' | 'failed' | 'timedOut' | 'skipped' | 'interrupted'
+      startTime?: string;
+      error?: { message?: string; stack?: string };
+      attachments?: Array<{ name?: string; path?: string; contentType?: string }>;
+    }>;
+  }>;
+}
+
+/**
+ * Recursively walk suites and collect (full-title → spec) pairs.
+ * Title stack is joined with " > " to match our SpecTest.testTitle format.
+ */
+function walkSuites(suites: PlaywrightSuite[] | undefined, titleStack: string[]): Map<string, PlaywrightSpec> {
+  const map = new Map<string, PlaywrightSpec>();
+  if (!suites) return map;
+  for (const suite of suites) {
+    const nextStack = suite.title ? [...titleStack, suite.title] : titleStack;
+    for (const spec of suite.specs || []) {
+      if (spec.title) {
+        const fullTitle = [...nextStack, spec.title].join(' > ');
+        map.set(fullTitle, spec);
+      }
+    }
+    const childMap = walkSuites(suite.suites, nextStack);
+    for (const [k, v] of childMap.entries()) map.set(k, v);
+  }
+  return map;
+}
+
+/**
+ * Load and parse results.json. Returns null if file missing or invalid.
+ */
+export function loadPlaywrightReport(reportPath: string): Map<string, PlaywrightResult> | null {
+  if (!fs.existsSync(reportPath)) return null;
+  let raw: PlaywrightJsonReport;
+  try {
+    const content = fs.readFileSync(reportPath, 'utf-8');
+    raw = JSON.parse(content);
+  } catch {
+    return null;
+  }
+
+  // The top-level "suites" array uses the spec file path as suite.title.
+  // Tests are nested deeper under describe() blocks.
+  // We walk all suites and map "describeTitle > nestedTitle > specTitle" → spec.
+  const specMap = walkSuites(raw.suites, []);
+
+  const result = new Map<string, PlaywrightResult>();
+  for (const [fullTitle, spec] of specMap.entries()) {
+    const test = spec.tests?.[0];
+    const res = test?.results?.[0];
+    const status = normalizeStatus(res?.status);
+    const errorMsg = res?.error?.message || '';
+    const trace = res?.attachments?.find((a) => a.name === 'trace' || a.contentType === 'application/zip')?.path;
+
+    // Strip the leading file-path suite title if present.
+    // The top-level suite title is usually a file path like "specs/generated/kudos/kudos.spec.ts".
+    // The test title we match against is "<Feature> > <auth> > <Scenario>".
+    const stripped = stripLeadingFilePathSuite(fullTitle);
+
+    result.set(stripped, {
+      testTitle: stripped,
+      status,
+      startTime: res?.startTime,
+      error: errorMsg,
+      tracePath: trace,
+    });
+  }
+  return result;
+}
+
+/**
+ * Normalize playwright status strings to our enum.
+ */
+function normalizeStatus(s: string | undefined): PlaywrightResult['status'] {
+  if (!s) return 'unknown';
+  if (s === 'passed') return 'passed';
+  if (s === 'failed') return 'failed';
+  if (s === 'timedOut') return 'timedOut';
+  if (s === 'skipped') return 'skipped';
+  if (s === 'interrupted') return 'interrupted';
+  return 'unknown';
+}
+
+/**
+ * If the full title starts with a file-path-looking suite title like
+ * "specs/generated/kudos/kudos.spec.ts > Feature Name > ...",
+ * strip that leading segment so matching works against "Feature Name > ...".
+ */
+function stripLeadingFilePathSuite(fullTitle: string): string {
+  const parts = fullTitle.split(' > ');
+  if (parts.length > 1 && /\.spec\.ts$/i.test(parts[0])) {
+    return parts.slice(1).join(' > ');
+  }
+  return fullTitle;
+}
+
+/**
+ * CSV "Test Result" column mapping.
+ */
+export function statusToTestResult(status: PlaywrightResult['status']): string {
+  switch (status) {
+    case 'passed':
+      return 'Passed';
+    case 'failed':
+    case 'timedOut':
+      return 'Failed';
+    case 'skipped':
+      return 'N/A';
+    case 'interrupted':
+      return 'Pending';
+    default:
+      return 'Pending';
+  }
+}
+
+/**
+ * Format startTime (ISO string) → "dd/mm/yyyy".
+ */
+export function formatExecutedDate(startTime: string | undefined): string {
+  if (!startTime) return '';
+  const d = new Date(startTime);
+  if (isNaN(d.getTime())) return '';
+  const dd = String(d.getDate()).padStart(2, '0');
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const yyyy = d.getFullYear();
+  return `${dd}/${mm}/${yyyy}`;
+}
+
+/**
+ * Format error message for Note column. Truncate long stacks, include trace path.
+ */
+export function formatNote(result: PlaywrightResult | undefined): string {
+  if (!result) return '';
+  if (result.status !== 'failed' && result.status !== 'timedOut') return '';
+  const firstLine = (result.error || '').split('\n')[0].trim();
+  const truncated = firstLine.length > 200 ? firstLine.substring(0, 197) + '…' : firstLine;
+  const parts: string[] = [];
+  if (truncated) parts.push(`Error: ${truncated}`);
+  if (result.tracePath) parts.push(`Trace: ${result.tracePath}`);
+  return parts.join('. ');
+}