@xera-ai/core 0.4.1 → 0.4.2

package/dist/bin/internal.js

@@ -8882,11 +8882,18 @@ var ReportingSchema = z4.object({
   }).prefault({}),
   artifactLinks: z4.enum(["git", "local"]).default("git")
 }).prefault({});
+var RunSchema = z4.object({
+  autoImpact: z4.object({
+    enabled: z4.boolean().default(true),
+    threshold: z4.number().nonnegative().default(6)
+  }).prefault({})
+}).prefault({});
 var XeraConfigSchema = z4.object({
   jira: JiraSchema,
   web: WebSchema,
   ai: AISchema,
   reporting: ReportingSchema,
+  run: RunSchema.prefault({}),
   adapters: z4.array(z4.string().min(1)).min(1).default(["web"])
 });
 
@@ -10050,6 +10057,267 @@ async function healPrepareCmd(argv) {
   }
 }
 
+// src/bin-internal/impact-prepare.ts
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
+import { join as join17 } from "path";
+
+// src/graph/impact.ts
+var PRIORITY_WEIGHT = { p0: 3, p1: 2, p2: 1 };
+var EDGE_WEIGHT_FIXED = {
+  modifies: 5,
+  uses: 4,
+  covers: 4
+};
+function jiraRelationWeight(source) {
+  if (!source)
+    return 0;
+  if (source.endsWith("blocks"))
+    return 4;
+  if (source.endsWith("duplicates"))
+    return 3;
+  if (source.endsWith("relates"))
+    return 2;
+  if (source.endsWith("supersedes"))
+    return 3;
+  return 1;
+}
+function edgeWeight(edge) {
+  if (edge.kind === "modifies")
+    return EDGE_WEIGHT_FIXED.modifies ?? 0;
+  if (edge.kind === "uses" || edge.kind === "covers")
+    return EDGE_WEIGHT_FIXED.uses ?? 0;
+  if (edge.kind === "jira-linked")
+    return jiraRelationWeight(edge.source);
+  if (edge.kind === "similar")
+    return 1 * (edge.confidence ?? 0);
+  return 0;
+}
+function riskScore(scenario, daysSinceLastPass) {
+  const pri = PRIORITY_WEIGHT[scenario.priority] * 3;
+  const firstEdge = scenario.edgePath[0];
+  const edgeW = firstEdge ? edgeWeight(firstEdge) : 0;
+  const confW = firstEdge?.confidence !== undefined ? firstEdge.confidence * 2 : 0;
+  const decay = daysSinceLastPass * 0.1;
+  return pri + edgeW + confW - decay;
+}
+var PRIORITY_RANK = { p0: 3, p1: 2, p2: 1 };
+function daysSince(ts) {
+  if (!ts)
+    return 0;
+  const ms = Date.now() - Date.parse(ts);
+  return ms < 0 ? 0 : ms / (86400 * 1000);
+}
+function walkImpact(graph, target, opts) {
+  const result = [];
+  const seen = new Set;
+  const targetAreas = new Set(target.modifiesAreas);
+  const pomIds = graph.edges.filter((e) => e.kind === "covers" && targetAreas.has(e.to)).map((e) => e.from);
+  const directScenarios = graph.edges.filter((e) => e.kind === "uses" && pomIds.includes(e.to)).map((e) => e.from);
+  for (const scenarioId2 of directScenarios) {
+    if (seen.has(scenarioId2))
+      continue;
+    const scenario = graph.scenarios[scenarioId2];
+    if (!scenario)
+      continue;
+    if (scenario.ticketId === target.id)
+      continue;
+    const usingPom = graph.edges.find((e) => e.kind === "uses" && e.from === scenarioId2);
+    const modifyEdge = graph.edges.find((e) => e.kind === "modifies" && e.from === target.id && targetAreas.has(e.to));
+    const edgePath = [];
+    if (modifyEdge)
+      edgePath.push({ kind: "modifies", from: modifyEdge.from, to: modifyEdge.to });
+    if (usingPom)
+      edgePath.push({ kind: "uses", from: usingPom.from, to: usingPom.to });
+    seen.add(scenarioId2);
+    const impact = {
+      scenarioId: scenarioId2,
+      ticketId: scenario.ticketId,
+      name: scenario.name,
+      priority: scenario.priority,
+      edgePath,
+      riskScore: 0
+    };
+    impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId2]?.ts));
+    result.push(impact);
+  }
+  if (opts.depth >= 2) {
+    const linked = graph.edges.filter((e) => e.kind === "jira-linked" && e.from === target.id).map((e) => ({ to: e.to, source: e.source }));
+    for (const link of linked) {
+      const sceneIds = graph.edges.filter((e) => e.kind === "tests" && e.from === link.to).map((e) => e.to);
+      for (const scenarioId2 of sceneIds) {
+        if (seen.has(scenarioId2))
+          continue;
+        const scenario = graph.scenarios[scenarioId2];
+        if (!scenario || scenario.ticketId === target.id)
+          continue;
+        seen.add(scenarioId2);
+        const edge = { kind: "jira-linked", from: target.id, to: link.to };
+        if (link.source !== undefined)
+          edge.source = link.source;
+        const impact = {
+          scenarioId: scenarioId2,
+          ticketId: scenario.ticketId,
+          name: scenario.name,
+          priority: scenario.priority,
+          edgePath: [edge],
+          riskScore: 0
+        };
+        impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId2]?.ts));
+        result.push(impact);
+      }
+    }
+  }
+  if (opts.depth >= 3) {
+    const similar = graph.edges.filter((e) => e.kind === "similar" && e.from === target.id).map((e) => ({ to: e.to, confidence: e.confidence }));
+    for (const link of similar) {
+      const sceneIds = graph.edges.filter((e) => e.kind === "tests" && e.from === link.to).map((e) => e.to);
+      for (const scenarioId2 of sceneIds) {
+        if (seen.has(scenarioId2))
+          continue;
+        const scenario = graph.scenarios[scenarioId2];
+        if (!scenario || scenario.ticketId === target.id)
+          continue;
+        seen.add(scenarioId2);
+        const edge = { kind: "similar", from: target.id, to: link.to };
+        if (link.confidence !== undefined)
+          edge.confidence = link.confidence;
+        const impact = {
+          scenarioId: scenarioId2,
+          ticketId: scenario.ticketId,
+          name: scenario.name,
+          priority: scenario.priority,
+          edgePath: [edge],
+          riskScore: 0
+        };
+        impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId2]?.ts));
+        result.push(impact);
+      }
+    }
+  }
+  let filtered = result;
+  if (opts.minPriority) {
+    const min = PRIORITY_RANK[opts.minPriority];
+    filtered = filtered.filter((s) => PRIORITY_RANK[s.priority] >= min);
+  }
+  filtered.sort((a, b) => b.riskScore - a.riskScore);
+  return filtered;
+}
+var HIGH_THRESHOLD = 7;
+var MEDIUM_THRESHOLD = 4;
+function bucket(score) {
+  if (score >= HIGH_THRESHOLD)
+    return "high";
+  if (score >= MEDIUM_THRESHOLD)
+    return "medium";
+  return "low";
+}
+function fmtEdgePath(path) {
+  return path.map((e) => `${e.from} \u2192[${e.kind}]\u2192 ${e.to}`).join(" \xB7 ");
+}
+function renderImpactMarkdown(report) {
+  const lines = [];
+  lines.push(`# Impact Analysis \u2014 ${report.targetTicket}`);
+  lines.push("");
+  lines.push(`**Modified areas:** ${report.modifiedAreas.join(", ") || "(none)"}`);
+  lines.push(`**Generated:** ${report.generatedAt}`);
+  lines.push("");
+  if (report.scenarios.length === 0) {
+    lines.push("No prior scenarios in the modified areas. This may be a new feature area.");
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  const bySeverity = {
+    high: [],
+    medium: [],
+    low: []
+  };
+  for (const s of report.scenarios)
+    bySeverity[bucket(s.riskScore)].push(s);
+  lines.push(`**Total impacted:** ${report.scenarios.length} scenarios (${bySeverity.high.length} high \xB7 ${bySeverity.medium.length} medium \xB7 ${bySeverity.low.length} low)`);
+  lines.push("");
+  for (const [name, scenarios] of [
+    ["High-risk", bySeverity.high],
+    ["Medium-risk", bySeverity.medium],
+    ["Low-risk", bySeverity.low]
+  ]) {
+    if (scenarios.length === 0)
+      continue;
+    lines.push(`## ${name}`);
+    lines.push("");
+    for (const s of scenarios) {
+      lines.push(`### ${s.ticketId} / "${s.name}" [${s.priority.toUpperCase()}]   score ${s.riskScore.toFixed(1)}`);
+      lines.push(`- Edge: ${fmtEdgePath(s.edgePath)}`);
+      if (s.lastPassedAt)
+        lines.push(`- Last passed: ${s.lastPassedAt}`);
+      lines.push("");
+    }
+  }
+  lines.push("## Re-run commands");
+  lines.push(`- All:        \`bun run xera:exec --from-impact ${report.targetTicket}\``);
+  lines.push(`- P0 only:    \`bun run xera:exec --from-impact ${report.targetTicket} --min-priority p0\``);
+  lines.push(`- Select:     \`bun run xera:exec --from-impact ${report.targetTicket} --select\``);
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/bin-internal/impact-prepare.ts
+init_store();
+function parseDepth(s) {
+  const n = s ? Number.parseInt(s, 10) : 2;
+  if (n === 1 || n === 3)
+    return n;
+  return 2;
+}
+function parseMinPriority(s) {
+  if (s === "p0" || s === "p1" || s === "p2")
+    return s;
+  return;
+}
+async function impactPrepareCmd(argv) {
+  const ticket = argv[0];
+  if (!ticket || ticket.startsWith("--")) {
+    console.error("[impact-prepare] usage: impact-prepare <TICKET> [--depth 1|2|3] [--min-priority p0|p1|p2] [--quiet]");
+    return 1;
+  }
+  let depth = 2;
+  let minPriority;
+  let quiet = false;
+  for (let i2 = 1;i2 < argv.length; i2++) {
+    if (argv[i2] === "--depth")
+      depth = parseDepth(argv[++i2]);
+    else if (argv[i2] === "--min-priority")
+      minPriority = parseMinPriority(argv[++i2]);
+    else if (argv[i2] === "--quiet")
+      quiet = true;
+  }
+  const repoRoot = process.cwd();
+  const graph = deriveSnapshot(loadAllEvents(repoRoot));
+  const target = graph.tickets[ticket];
+  if (!target) {
+    console.error(`[impact-prepare] ticket ${ticket} not in graph; run /xera-fetch first`);
+    return 2;
+  }
+  const opts = { depth };
+  if (minPriority)
+    opts.minPriority = minPriority;
+  const scenarios = walkImpact(graph, target, opts);
+  const report = {
+    targetTicket: ticket,
+    modifiedAreas: target.modifiesAreas,
+    scenarios,
+    generatedAt: new Date().toISOString()
+  };
+  const impactDir = join17(repoRoot, ".xera/impact");
+  mkdirSync11(impactDir, { recursive: true });
+  writeFileSync11(join17(impactDir, `${ticket}.json`), JSON.stringify(report, null, 2));
+  if (!quiet) {
+    writeFileSync11(join17(impactDir, `${ticket}.md`), renderImpactMarkdown(report));
+  }
+  return 0;
+}
+
 // src/bin-internal/lint.ts
 import { lintTicket } from "@xera-ai/web";
 async function lintCmd(argv) {
@@ -10071,7 +10339,7 @@ async function lintCmd(argv) {
 
 // src/bin-internal/normalize.ts
 import { existsSync as existsSync21, readdirSync as readdirSync7 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { normalizeRun } from "@xera-ai/web";
 async function normalizeCmd(argv) {
   const ticket = argv[0];
@@ -10086,7 +10354,7 @@ async function normalizeCmd(argv) {
     console.error("[xera:normalize] no run found");
     return 1;
   }
-  const runDir = join17(paths.runsDir, runId);
+  const runDir = join18(paths.runsDir, runId);
   if (!existsSync21(runDir)) {
     console.error(`[xera:normalize] runs/${runId} missing`);
     return 1;
@@ -10098,10 +10366,10 @@ async function normalizeCmd(argv) {
 
 // src/bin-internal/post.ts
 import { existsSync as existsSync23, readFileSync as readFileSync19 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/artifact/status.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname6 } from "path";
 import { z as z7 } from "zod";
 var ClassificationEnum = z7.enum([
@@ -10141,8 +10409,8 @@ function readStatus(path) {
   return StatusJsonSchema.parse(JSON.parse(readFileSync18(path, "utf8")));
 }
 function writeStatus(path, status) {
-  mkdirSync11(dirname6(path), { recursive: true });
-  writeFileSync11(path, JSON.stringify(status, null, 2));
+  mkdirSync12(dirname6(path), { recursive: true });
+  writeFileSync12(path, JSON.stringify(status, null, 2));
 }
 function appendHistory(path, entry) {
   const s = readStatus(path);
@@ -10168,7 +10436,7 @@ async function postCmd(argv) {
     return 0;
   }
   const paths = resolveArtifactPaths(cwd, ticket);
-  const draftPath = join18(paths.ticketDir, "jira-comment.draft.md");
+  const draftPath = join19(paths.ticketDir, "jira-comment.draft.md");
   if (!existsSync23(draftPath)) {
     console.error(`[xera:post] no draft at ${draftPath}; run \`xera-internal report\` first.`);
     return 1;
@@ -10201,8 +10469,8 @@ async function promoteCmd(argv) {
 }
 
 // src/bin-internal/report.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "fs";
+import { join as join20 } from "path";
 
 // src/classifier/aggregate.ts
 var CLASS_PRIORITY = [
@@ -10376,7 +10644,7 @@ async function reportCmd(argv) {
   const paths = resolveArtifactPaths(process.cwd(), ticket);
   const input = JSON.parse(readFileSync20(inputArg.slice("--input=".length), "utf8"));
   const aggregated = aggregateScenarios(input.scenarios);
-  const decisionsPath = join19(paths.ticketDir, "runs", input.runId, "outdated-decisions.json");
+  const decisionsPath = join20(paths.ticketDir, "runs", input.runId, "outdated-decisions.json");
   const decisions = existsSync25(decisionsPath) ? JSON.parse(readFileSync20(decisionsPath, "utf8")) : {};
   const graph = deriveSnapshot(loadAllEvents(process.cwd()));
   const normalizeScenarioName = (name) => name.trim().toLowerCase().replace(/\s+/g, " ");
@@ -10425,8 +10693,8 @@ async function reportCmd(argv) {
     xeraVersion: "0.1.0",
     promptsVersion: "1.0.0"
   });
-  const draftPath = join19(paths.ticketDir, "jira-comment.draft.md");
-  writeFileSync12(draftPath, md);
+  const draftPath = join20(paths.ticketDir, "jira-comment.draft.md");
+  writeFileSync13(draftPath, md);
   console.log(`[xera:report] wrote status.json and ${draftPath}`);
   return 0;
 }
@@ -10530,6 +10798,7 @@ var COMMANDS = {
   "graph-record": graphRecordCmd,
   "graph-snapshot": graphSnapshotCmd,
   "heal-prepare": healPrepareCmd,
+  "impact-prepare": impactPrepareCmd,
   lint: lintCmd,
   normalize: normalizeCmd,
   post: postCmd,

package/dist/bin-internal/impact-prepare.d.ts

@@ -0,0 +1,2 @@
+export declare function impactPrepareCmd(argv: string[]): Promise<number>;
+//# sourceMappingURL=impact-prepare.d.ts.map

package/dist/bin-internal/impact-prepare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact-prepare.d.ts","sourceRoot":"","sources":["../../src/bin-internal/impact-prepare.ts"],"names":[],"mappings":"AAkBA,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA6CtE"}

package/dist/bin-internal/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin-internal/index.ts"],"names":[],"mappings":"AAgDA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAczD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin-internal/index.ts"],"names":[],"mappings":"AAkDA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAczD"}

package/dist/config/schema.d.ts

@@ -60,6 +60,12 @@ export declare const XeraConfigSchema: z.ZodObject<{
             local: "local";
         }>>;
     }, z.core.$strip>>;
+    run: z.ZodPrefault<z.ZodPrefault<z.ZodObject<{
+        autoImpact: z.ZodPrefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            threshold: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
     adapters: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type XeraConfig = z.infer<typeof XeraConfigSchema>;

package/dist/config/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuExB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkFxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/graph/impact.d.ts

@@ -0,0 +1,31 @@
+import type { EdgeKind, Priority, Snapshot, TicketNode } from './types';
+export interface ImpactEdge {
+    kind: EdgeKind;
+    from: string;
+    to: string;
+    confidence?: number;
+    source?: string;
+}
+export interface ImpactScenario {
+    scenarioId: string;
+    ticketId: string;
+    name: string;
+    priority: Priority;
+    edgePath: ImpactEdge[];
+    riskScore: number;
+    lastPassedAt?: string;
+}
+export interface ImpactOpts {
+    depth: 1 | 2 | 3;
+    minPriority?: Priority;
+}
+export interface ImpactReport {
+    targetTicket: string;
+    modifiedAreas: string[];
+    scenarios: ImpactScenario[];
+    generatedAt: string;
+}
+export declare function riskScore(scenario: ImpactScenario, daysSinceLastPass: number): number;
+export declare function walkImpact(graph: Snapshot, target: TicketNode, opts: ImpactOpts): ImpactScenario[];
+export declare function renderImpactMarkdown(report: ImpactReport): string;
+//# sourceMappingURL=impact.d.ts.map

package/dist/graph/impact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact.d.ts","sourceRoot":"","sources":["../../src/graph/impact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjB,WAAW,CAAC,EAAE,QAAQ,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,SAAS,EAAE,cAAc,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;CACrB;AA4BD,wBAAgB,SAAS,CAAC,QAAQ,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAOrF;AAUD,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,UAAU,GACf,cAAc,EAAE,CAkHlB;AAeD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAqDjE"}

package/dist/graph/index.d.ts

@@ -4,6 +4,8 @@ export type { CostSummary, LlmCallLog } from './cost';
 export { logLlmCall, summarizeCost } from './cost';
 export type { EnrichOptions, EnrichResult } from './enrich';
 export { enrichTicket } from './enrich';
+export type { ImpactEdge, ImpactOpts, ImpactReport, ImpactScenario, } from './impact';
+export { renderImpactMarkdown, riskScore, walkImpact, } from './impact';
 export { currentYyyyMm, graphPaths } from './paths';
 export { EventSchema, safeParseEvent } from './schema';
 export { buildSimilarityPrompt } from './similarity';

package/dist/graph/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graph/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,cAAc,EACd,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graph/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,cAAc,EACd,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,YAAY,EACV,UAAU,EACV,UAAU,EACV,YAAY,EACZ,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,oBAAoB,EACpB,SAAS,EACT,UAAU,GACX,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,aAAa,EACb,YAAY,EACZ,aAAa,GACd,MAAM,SAAS,CAAC;AACjB,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC"}

package/dist/src/index.js

@@ -324,11 +324,18 @@ var ReportingSchema = z4.object({
   }).prefault({}),
   artifactLinks: z4.enum(["git", "local"]).default("git")
 }).prefault({});
+var RunSchema = z4.object({
+  autoImpact: z4.object({
+    enabled: z4.boolean().default(true),
+    threshold: z4.number().nonnegative().default(6)
+  }).prefault({})
+}).prefault({});
 var XeraConfigSchema = z4.object({
   jira: JiraSchema,
   web: WebSchema,
   ai: AISchema,
   reporting: ReportingSchema,
+  run: RunSchema.prefault({}),
   adapters: z4.array(z4.string().min(1)).min(1).default(["web"])
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xera-ai/core",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

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

@@ -0,0 +1,64 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ImpactOpts, ImpactReport } from '../graph/impact';
+import { renderImpactMarkdown, walkImpact } from '../graph/impact';
+import { deriveSnapshot, loadAllEvents } from '../graph/store';
+import type { Priority } from '../graph/types';
+
+function parseDepth(s: string | undefined): 1 | 2 | 3 {
+  const n = s ? Number.parseInt(s, 10) : 2;
+  if (n === 1 || n === 3) return n;
+  return 2;
+}
+
+function parseMinPriority(s: string | undefined): Priority | undefined {
+  if (s === 'p0' || s === 'p1' || s === 'p2') return s;
+  return undefined;
+}
+
+export async function impactPrepareCmd(argv: string[]): Promise<number> {
+  const ticket = argv[0];
+  if (!ticket || ticket.startsWith('--')) {
+    console.error(
+      '[impact-prepare] usage: impact-prepare <TICKET> [--depth 1|2|3] [--min-priority p0|p1|p2] [--quiet]',
+    );
+    return 1;
+  }
+
+  let depth: 1 | 2 | 3 = 2;
+  let minPriority: Priority | undefined;
+  let quiet = false;
+  for (let i = 1; i < argv.length; i++) {
+    if (argv[i] === '--depth') depth = parseDepth(argv[++i]);
+    else if (argv[i] === '--min-priority') minPriority = parseMinPriority(argv[++i]);
+    else if (argv[i] === '--quiet') quiet = true;
+  }
+
+  const repoRoot = process.cwd();
+  const graph = deriveSnapshot(loadAllEvents(repoRoot));
+  const target = graph.tickets[ticket];
+  if (!target) {
+    console.error(`[impact-prepare] ticket ${ticket} not in graph; run /xera-fetch first`);
+    return 2;
+  }
+
+  const opts: ImpactOpts = { depth };
+  if (minPriority) opts.minPriority = minPriority;
+
+  const scenarios = walkImpact(graph, target, opts);
+
+  const report: ImpactReport = {
+    targetTicket: ticket,
+    modifiedAreas: target.modifiesAreas,
+    scenarios,
+    generatedAt: new Date().toISOString(),
+  };
+
+  const impactDir = join(repoRoot, '.xera/impact');
+  mkdirSync(impactDir, { recursive: true });
+  writeFileSync(join(impactDir, `${ticket}.json`), JSON.stringify(report, null, 2));
+  if (!quiet) {
+    writeFileSync(join(impactDir, `${ticket}.md`), renderImpactMarkdown(report));
+  }
+  return 0;
+}

package/src/bin-internal/index.ts

@@ -10,6 +10,7 @@ import { graphQueryCmd } from './graph-query';
 import { graphRecordCmd } from './graph-record';
 import { graphSnapshotCmd } from './graph-snapshot';
 import { healPrepareCmd } from './heal-prepare';
+import { impactPrepareCmd } from './impact-prepare';
 import { lintCmd } from './lint';
 import { normalizeCmd } from './normalize';
 import { postCmd } from './post';
@@ -34,6 +35,7 @@ const COMMANDS: Record<string, (argv: string[]) => Promise<number>> = {
   'graph-record': graphRecordCmd,
   'graph-snapshot': graphSnapshotCmd,
   'heal-prepare': healPrepareCmd,
+  'impact-prepare': impactPrepareCmd,
   lint: lintCmd,
   normalize: normalizeCmd,
   post: postCmd,

package/src/config/schema.ts

@@ -69,11 +69,23 @@ const ReportingSchema = z
   })
   .prefault({});
 
+const RunSchema = z
+  .object({
+    autoImpact: z
+      .object({
+        enabled: z.boolean().default(true),
+        threshold: z.number().nonnegative().default(6.0),
+      })
+      .prefault({}),
+  })
+  .prefault({});
+
 export const XeraConfigSchema = z.object({
   jira: JiraSchema,
   web: WebSchema,
   ai: AISchema,
   reporting: ReportingSchema,
+  run: RunSchema.prefault({}),
   adapters: z.array(z.string().min(1)).min(1).default(['web']),
 });
 

package/src/graph/impact.ts

@@ -0,0 +1,262 @@
+import type { EdgeKind, Priority, Snapshot, TicketNode } from './types';
+
+export interface ImpactEdge {
+  kind: EdgeKind;
+  from: string;
+  to: string;
+  confidence?: number;
+  source?: string;
+}
+
+export interface ImpactScenario {
+  scenarioId: string;
+  ticketId: string; // owner of the scenario (NOT the impact target)
+  name: string;
+  priority: Priority;
+  edgePath: ImpactEdge[];
+  riskScore: number;
+  lastPassedAt?: string;
+}
+
+export interface ImpactOpts {
+  depth: 1 | 2 | 3;
+  minPriority?: Priority;
+}
+
+export interface ImpactReport {
+  targetTicket: string;
+  modifiedAreas: string[];
+  scenarios: ImpactScenario[];
+  generatedAt: string;
+}
+
+const PRIORITY_WEIGHT: Record<Priority, number> = { p0: 3, p1: 2, p2: 1 };
+
+const EDGE_WEIGHT_FIXED: Partial<Record<EdgeKind, number>> = {
+  modifies: 5, // direct collision via SUT area
+  uses: 4, // shared POM
+  covers: 4, // shared POM (alt path)
+  // 'jira-linked' weight is dynamic — see jiraRelationWeight
+};
+
+function jiraRelationWeight(source?: string): number {
+  if (!source) return 0;
+  if (source.endsWith('blocks')) return 4;
+  if (source.endsWith('duplicates')) return 3;
+  if (source.endsWith('relates')) return 2;
+  if (source.endsWith('supersedes')) return 3;
+  return 1;
+}
+
+function edgeWeight(edge: ImpactEdge): number {
+  if (edge.kind === 'modifies') return EDGE_WEIGHT_FIXED.modifies ?? 0;
+  if (edge.kind === 'uses' || edge.kind === 'covers') return EDGE_WEIGHT_FIXED.uses ?? 0;
+  if (edge.kind === 'jira-linked') return jiraRelationWeight(edge.source);
+  if (edge.kind === 'similar') return 1 * (edge.confidence ?? 0);
+  return 0;
+}
+
+export function riskScore(scenario: ImpactScenario, daysSinceLastPass: number): number {
+  const pri = PRIORITY_WEIGHT[scenario.priority] * 3;
+  const firstEdge = scenario.edgePath[0];
+  const edgeW = firstEdge ? edgeWeight(firstEdge) : 0;
+  const confW = firstEdge?.confidence !== undefined ? firstEdge.confidence * 2 : 0;
+  const decay = daysSinceLastPass * 0.1;
+  return pri + edgeW + confW - decay;
+}
+
+const PRIORITY_RANK: Record<Priority, number> = { p0: 3, p1: 2, p2: 1 };
+
+function daysSince(ts: string | undefined): number {
+  if (!ts) return 0;
+  const ms = Date.now() - Date.parse(ts);
+  return ms < 0 ? 0 : ms / (86400 * 1000);
+}
+
+export function walkImpact(
+  graph: Snapshot,
+  target: TicketNode,
+  opts: ImpactOpts,
+): ImpactScenario[] {
+  const result: ImpactScenario[] = [];
+  const seen = new Set<string>();
+
+  // Areas the target modifies
+  const targetAreas = new Set(target.modifiesAreas);
+
+  // POMs covering any of those areas
+  const pomIds = graph.edges
+    .filter((e) => e.kind === 'covers' && targetAreas.has(e.to))
+    .map((e) => e.from);
+
+  // Scenarios using any of those POMs (depth 1 — direct collision)
+  const directScenarios = graph.edges
+    .filter((e) => e.kind === 'uses' && pomIds.includes(e.to))
+    .map((e) => e.from);
+
+  for (const scenarioId of directScenarios) {
+    if (seen.has(scenarioId)) continue;
+    const scenario = graph.scenarios[scenarioId];
+    if (!scenario) continue;
+    if (scenario.ticketId === target.id) continue; // exclude own scenarios
+
+    const usingPom = graph.edges.find((e) => e.kind === 'uses' && e.from === scenarioId);
+    const modifyEdge = graph.edges.find(
+      (e) => e.kind === 'modifies' && e.from === target.id && targetAreas.has(e.to),
+    );
+    const edgePath: ImpactEdge[] = [];
+    if (modifyEdge) edgePath.push({ kind: 'modifies', from: modifyEdge.from, to: modifyEdge.to });
+    if (usingPom) edgePath.push({ kind: 'uses', from: usingPom.from, to: usingPom.to });
+
+    seen.add(scenarioId);
+    const impact: ImpactScenario = {
+      scenarioId,
+      ticketId: scenario.ticketId,
+      name: scenario.name,
+      priority: scenario.priority,
+      edgePath,
+      riskScore: 0,
+    };
+    impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId]?.ts));
+    result.push(impact);
+  }
+
+  // Depth >= 2: jira-linked tickets contribute their scenarios
+  if (opts.depth >= 2) {
+    const linked = graph.edges
+      .filter((e) => e.kind === 'jira-linked' && e.from === target.id)
+      .map((e) => ({ to: e.to, source: e.source }));
+    for (const link of linked) {
+      const sceneIds = graph.edges
+        .filter((e) => e.kind === 'tests' && e.from === link.to)
+        .map((e) => e.to);
+      for (const scenarioId of sceneIds) {
+        if (seen.has(scenarioId)) continue;
+        const scenario = graph.scenarios[scenarioId];
+        if (!scenario || scenario.ticketId === target.id) continue;
+        seen.add(scenarioId);
+        const edge: ImpactEdge = { kind: 'jira-linked', from: target.id, to: link.to };
+        if (link.source !== undefined) edge.source = link.source;
+        const impact: ImpactScenario = {
+          scenarioId,
+          ticketId: scenario.ticketId,
+          name: scenario.name,
+          priority: scenario.priority,
+          edgePath: [edge],
+          riskScore: 0,
+        };
+        impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId]?.ts));
+        result.push(impact);
+      }
+    }
+  }
+
+  // Depth >= 3: similar tickets contribute their scenarios
+  if (opts.depth >= 3) {
+    const similar = graph.edges
+      .filter((e) => e.kind === 'similar' && e.from === target.id)
+      .map((e) => ({ to: e.to, confidence: e.confidence }));
+    for (const link of similar) {
+      const sceneIds = graph.edges
+        .filter((e) => e.kind === 'tests' && e.from === link.to)
+        .map((e) => e.to);
+      for (const scenarioId of sceneIds) {
+        if (seen.has(scenarioId)) continue;
+        const scenario = graph.scenarios[scenarioId];
+        if (!scenario || scenario.ticketId === target.id) continue;
+        seen.add(scenarioId);
+        const edge: ImpactEdge = { kind: 'similar', from: target.id, to: link.to };
+        if (link.confidence !== undefined) edge.confidence = link.confidence;
+        const impact: ImpactScenario = {
+          scenarioId,
+          ticketId: scenario.ticketId,
+          name: scenario.name,
+          priority: scenario.priority,
+          edgePath: [edge],
+          riskScore: 0,
+        };
+        impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId]?.ts));
+        result.push(impact);
+      }
+    }
+  }
+
+  // Filter by min-priority
+  let filtered = result;
+  if (opts.minPriority) {
+    const min = PRIORITY_RANK[opts.minPriority];
+    filtered = filtered.filter((s) => PRIORITY_RANK[s.priority] >= min);
+  }
+
+  // Sort by riskScore descending
+  filtered.sort((a, b) => b.riskScore - a.riskScore);
+  return filtered;
+}
+
+const HIGH_THRESHOLD = 7.0;
+const MEDIUM_THRESHOLD = 4.0;
+
+function bucket(score: number): 'high' | 'medium' | 'low' {
+  if (score >= HIGH_THRESHOLD) return 'high';
+  if (score >= MEDIUM_THRESHOLD) return 'medium';
+  return 'low';
+}
+
+function fmtEdgePath(path: ImpactEdge[]): string {
+  return path.map((e) => `${e.from} →[${e.kind}]→ ${e.to}`).join(' · ');
+}
+
+export function renderImpactMarkdown(report: ImpactReport): string {
+  const lines: string[] = [];
+  lines.push(`# Impact Analysis — ${report.targetTicket}`);
+  lines.push('');
+  lines.push(`**Modified areas:** ${report.modifiedAreas.join(', ') || '(none)'}`);
+  lines.push(`**Generated:** ${report.generatedAt}`);
+  lines.push('');
+
+  if (report.scenarios.length === 0) {
+    lines.push('No prior scenarios in the modified areas. This may be a new feature area.');
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  const bySeverity = {
+    high: [] as ImpactScenario[],
+    medium: [] as ImpactScenario[],
+    low: [] as ImpactScenario[],
+  };
+  for (const s of report.scenarios) bySeverity[bucket(s.riskScore)].push(s);
+
+  lines.push(
+    `**Total impacted:** ${report.scenarios.length} scenarios (${bySeverity.high.length} high · ${bySeverity.medium.length} medium · ${bySeverity.low.length} low)`,
+  );
+  lines.push('');
+
+  for (const [name, scenarios] of [
+    ['High-risk', bySeverity.high],
+    ['Medium-risk', bySeverity.medium],
+    ['Low-risk', bySeverity.low],
+  ] as const) {
+    if (scenarios.length === 0) continue;
+    lines.push(`## ${name}`);
+    lines.push('');
+    for (const s of scenarios) {
+      lines.push(
+        `### ${s.ticketId} / "${s.name}" [${s.priority.toUpperCase()}]   score ${s.riskScore.toFixed(1)}`,
+      );
+      lines.push(`- Edge: ${fmtEdgePath(s.edgePath)}`);
+      if (s.lastPassedAt) lines.push(`- Last passed: ${s.lastPassedAt}`);
+      lines.push('');
+    }
+  }
+
+  lines.push('## Re-run commands');
+  lines.push(`- All:        \`bun run xera:exec --from-impact ${report.targetTicket}\``);
+  lines.push(
+    `- P0 only:    \`bun run xera:exec --from-impact ${report.targetTicket} --min-priority p0\``,
+  );
+  lines.push(`- Select:     \`bun run xera:exec --from-impact ${report.targetTicket} --select\``);
+  lines.push('');
+
+  return lines.join('\n');
+}

package/src/graph/index.ts

@@ -14,6 +14,17 @@ export type { CostSummary, LlmCallLog } from './cost';
 export { logLlmCall, summarizeCost } from './cost';
 export type { EnrichOptions, EnrichResult } from './enrich';
 export { enrichTicket } from './enrich';
+export type {
+  ImpactEdge,
+  ImpactOpts,
+  ImpactReport,
+  ImpactScenario,
+} from './impact';
+export {
+  renderImpactMarkdown,
+  riskScore,
+  walkImpact,
+} from './impact';
 export { currentYyyyMm, graphPaths } from './paths';
 export { EventSchema, safeParseEvent } from './schema';
 export { buildSimilarityPrompt } from './similarity';