gorsee 0.2.4 → 0.2.6

package/dist-pkg/ai/artifact-lifecycle.js

@@ -0,0 +1,98 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export async function writeArtifactLifecycleEvent(input) {
+  const gorseeDir = join(input.cwd, ".gorsee");
+  await mkdir(gorseeDir, { recursive: !0 });
+  const ts = new Date().toISOString();
+  await appendFile(join(gorseeDir, "ai-events.jsonl"), `${JSON.stringify({
+    id: crypto.randomUUID(),
+    kind: input.kind,
+    severity: input.severity,
+    ts,
+    source: input.source,
+    message: input.message,
+    code: input.code,
+    phase: input.phase,
+    data: input.data
+  })}
+`, "utf-8");
+}
+export async function writeArtifactSuccessPack(cwd) {
+  const repoCliEntry = join(import.meta.dir, "..", "cli", "index.ts");
+  try {
+    await Bun.$`bun run ${repoCliEntry} ai pack`.cwd(cwd).quiet();
+  } catch {}
+}
+export async function writeArtifactFailurePack(cwd, source, kind, code, message) {
+  const gorseeDir = join(cwd, ".gorsee");
+  await mkdir(gorseeDir, { recursive: !0 });
+  const ts = new Date().toISOString();
+  await appendFile(join(gorseeDir, "ai-events.jsonl"), `${JSON.stringify({
+    id: crypto.randomUUID(),
+    kind,
+    severity: "error",
+    ts,
+    source,
+    message,
+    code
+  })}
+`, "utf-8");
+  await writeFile(join(gorseeDir, "ai-diagnostics.json"), JSON.stringify({
+    updatedAt: ts,
+    latest: {
+      code,
+      message,
+      severity: "error",
+      source
+    }
+  }, null, 2), "utf-8");
+  await writeArtifactSuccessPack(cwd);
+}
+export async function runArtifactLifecycleStep(input) {
+  await writeArtifactLifecycleEvent({
+    cwd: input.cwd,
+    source: input.source,
+    phase: input.phase,
+    kind: `${input.step}.start`,
+    severity: "info",
+    message: input.startMessage,
+    data: {
+      version: input.version,
+      ...input.data ?? {}
+    }
+  });
+  try {
+    const result = await input.run();
+    await writeArtifactLifecycleEvent({
+      cwd: input.cwd,
+      source: input.source,
+      phase: input.phase,
+      kind: `${input.step}.finish`,
+      severity: "info",
+      message: input.finishMessage,
+      data: {
+        version: input.version,
+        ...input.data ?? {}
+      }
+    });
+    await writeArtifactSuccessPack(input.cwd);
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await writeArtifactLifecycleEvent({
+      cwd: input.cwd,
+      source: input.source,
+      phase: input.phase,
+      kind: `${input.step}.error`,
+      severity: "error",
+      message,
+      code: input.code,
+      data: {
+        version: input.version,
+        ...input.data ?? {}
+      }
+    });
+    await writeArtifactFailurePack(input.cwd, input.source, `${input.step}.failure`, input.code ?? "ARTIFACT_STEP", message);
+    throw error;
+  }
+}

package/dist-pkg/ai/bridge.d.ts

@@ -0,0 +1,26 @@
+import type { AIDiagnostic, AIEvent } from "./index.js";
+export interface AIBridgeServerOptions {
+    port?: number;
+    path?: string;
+    host?: string;
+    maxEvents?: number;
+    maxBodyBytes?: number;
+    persistPath?: string;
+    onEvent?: (event: AIEvent) => void | Promise<void>;
+}
+export interface AIBridgeSnapshot {
+    updatedAt: string | null;
+    events: AIEvent[];
+    diagnostics: AIDiagnostic[];
+}
+export interface AIBridgeHandler {
+    fetch(request: Request): Promise<Response> | Response;
+    snapshot(): AIBridgeSnapshot;
+}
+export interface AIBridgeServer {
+    port: number;
+    stop(closeActiveConnections?: boolean): void;
+    snapshot(): AIBridgeSnapshot;
+}
+export declare function createAIBridgeHandler(options?: AIBridgeServerOptions): AIBridgeHandler;
+export declare function createAIBridgeServer(options?: AIBridgeServerOptions): AIBridgeServer;

package/dist-pkg/ai/bridge.js

@@ -0,0 +1,82 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { isRecord, MAX_AI_JSON_BYTES, safeJSONParse } from "./json.js";
+export function createAIBridgeHandler(options = {}) {
+  const path = options.path ?? "/gorsee/ai-events", maxEvents = options.maxEvents ?? 200, maxBodyBytes = options.maxBodyBytes ?? MAX_AI_JSON_BYTES, events = [], diagnostics = [];
+  let updatedAt = null;
+  return {
+    async fetch(request) {
+      const url = new URL(request.url);
+      if (request.method === "GET" && url.pathname === `${path}/health`)
+        return Response.json({ status: "ok", updatedAt });
+      if (request.method === "GET" && url.pathname === `${path}/events`)
+        return Response.json(snapshot());
+      if (request.method !== "POST" || url.pathname !== path)
+        return new Response("Not Found", { status: 404 });
+      if (!(request.headers.get("content-type") ?? "").includes("application/json"))
+        return Response.json({ error: "Unsupported media type" }, { status: 415 });
+      if (Number(request.headers.get("content-length") ?? "0") > maxBodyBytes)
+        return Response.json({ error: "Payload too large" }, { status: 413 });
+      const raw = await request.text();
+      if (Buffer.byteLength(raw, "utf-8") > maxBodyBytes)
+        return Response.json({ error: "Payload too large" }, { status: 413 });
+      const event = safeJSONParse(raw, { maxBytes: maxBodyBytes });
+      if (!event || !isValidAIEvent(event))
+        return Response.json({ error: "Invalid AI event payload" }, { status: 400 });
+      updatedAt = event.ts;
+      events.push(event);
+      if (events.length > maxEvents)
+        events.shift();
+      if (event.kind === "diagnostic.issue") {
+        diagnostics.push({
+          code: event.code ?? "UNKNOWN",
+          message: event.message,
+          severity: event.severity === "debug" ? "info" : event.severity,
+          source: event.source,
+          file: event.file,
+          line: event.line,
+          route: event.route,
+          fix: typeof event.data?.fix === "string" ? event.data.fix : void 0,
+          ts: event.ts
+        });
+        if (diagnostics.length > maxEvents)
+          diagnostics.shift();
+      }
+      if (options.persistPath) {
+        await mkdir(dirname(options.persistPath), { recursive: !0 });
+        await appendFile(options.persistPath, `${JSON.stringify(event)}
+`, "utf-8");
+      }
+      if (options.onEvent)
+        await options.onEvent(event);
+      return Response.json({ ok: !0 });
+    },
+    snapshot
+  };
+  function snapshot() {
+    return {
+      updatedAt,
+      events: [...events],
+      diagnostics: [...diagnostics]
+    };
+  }
+}
+function isValidAIEvent(value) {
+  return isRecord(value) && typeof value.id === "string" && typeof value.kind === "string" && typeof value.severity === "string" && typeof value.ts === "string" && typeof value.source === "string" && typeof value.message === "string";
+}
+export function createAIBridgeServer(options = {}) {
+  const handler = createAIBridgeHandler(options), server = Bun.serve({
+    hostname: options.host ?? "127.0.0.1",
+    port: options.port ?? 4318,
+    fetch: handler.fetch
+  });
+  return {
+    port: server.port ?? options.port ?? 4318,
+    stop(closeActiveConnections = !1) {
+      server.stop(closeActiveConnections);
+    },
+    snapshot() {
+      return handler.snapshot();
+    }
+  };
+}

package/dist-pkg/ai/bundle.d.ts

@@ -0,0 +1,46 @@
+import type { AIDiagnostic, AIEvent } from "./index.js";
+import type { AIStorePaths, AIHealthReport } from "./store.js";
+import { type AIContextPacket } from "./summary.js";
+export interface AIContextSnippet {
+    file: string;
+    startLine: number;
+    endLine: number;
+    reason: string;
+    score: number;
+    content: string;
+}
+export interface AIContextBundle {
+    schemaVersion: string;
+    generatedAt: string;
+    packet: AIContextPacket;
+    report: AIHealthReport;
+    diagnostics: {
+        updatedAt?: string;
+        sessionId?: string;
+        latest?: Partial<AIDiagnostic>;
+    } | null;
+    recentEvents: AIEvent[];
+    artifacts: Array<{
+        kind: string;
+        path?: string;
+        version?: string;
+        message: string;
+        ts: string;
+    }>;
+    rootCauses: Array<{
+        key: string;
+        score: number;
+        kind: string;
+        route?: string;
+        file?: string;
+        latestTs: string;
+        reasons: string[];
+    }>;
+    snippets: AIContextSnippet[];
+}
+export declare function buildAIContextBundle(cwd: string, paths: AIStorePaths, options?: {
+    limit?: number;
+    snippetRadius?: number;
+    maxSnippets?: number;
+}): Promise<AIContextBundle>;
+export declare function renderAIContextBundleMarkdown(bundle: AIContextBundle): string;

package/dist-pkg/ai/bundle.js

@@ -0,0 +1,247 @@
+import { readFile } from "node:fs/promises";
+import { join, isAbsolute } from "node:path";
+import { buildAIHealthReport, readAIDiagnosticsSnapshot, readAIEvents, readReactiveTraceArtifact } from "./store.js";
+import { createAIContextPacket, renderAIContextMarkdown } from "./summary.js";
+import { GORSEE_AI_CONTEXT_SCHEMA_VERSION } from "./contracts.js";
+export async function buildAIContextBundle(cwd, paths, options = {}) {
+  const events = await readAIEvents(paths.eventsPath, { limit: options.limit ?? 200 }), diagnostics = await readAIDiagnosticsSnapshot(paths.diagnosticsPath), reactiveTrace = await readReactiveTraceArtifact(paths.reactiveTracePath), report = await buildAIHealthReport(paths, { limit: options.limit ?? 200 }), packet = createAIContextPacket(report, events, diagnostics?.latest, reactiveTrace), rootCauses = buildRootCauseRanking(report, diagnostics?.latest, events), snippets = await collectSnippets(cwd, diagnostics?.latest, report, events, rootCauses, {
+    snippetRadius: options.snippetRadius ?? 6,
+    maxSnippets: options.maxSnippets ?? 5
+  });
+  return {
+    schemaVersion: GORSEE_AI_CONTEXT_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    packet,
+    report,
+    diagnostics,
+    recentEvents: events.slice(-50),
+    artifacts: collectArtifacts(events),
+    rootCauses,
+    snippets
+  };
+}
+export function renderAIContextBundleMarkdown(bundle) {
+  const lines = [
+    renderAIContextMarkdown(bundle.packet),
+    "",
+    `Bundle Schema: ${bundle.schemaVersion}`,
+    "",
+    "## Root Causes",
+    ""
+  ];
+  if (bundle.artifacts.length > 0) {
+    lines.push("## Artifacts", "");
+    for (const artifact of bundle.artifacts.slice(0, 5)) {
+      const details = [artifact.version, artifact.path].filter(Boolean).join(" ");
+      lines.push(`- ${artifact.kind}: ${artifact.message}${details ? ` (${details})` : ""}`);
+    }
+    lines.push("");
+  }
+  if (bundle.rootCauses.length === 0)
+    lines.push("- No root-cause candidates ranked yet.");
+  else
+    for (const cause of bundle.rootCauses.slice(0, 5)) {
+      const loc = cause.file ? ` (${cause.file})` : cause.route ? ` (${cause.route})` : "";
+      lines.push(`- ${cause.kind} score=${cause.score}${loc}`);
+      if (cause.reasons.length > 0)
+        lines.push(`  reasons: ${cause.reasons.join(", ")}`);
+    }
+  lines.push("", "## Snippets", "");
+  if (bundle.snippets.length === 0)
+    lines.push("- No relevant snippets collected.");
+  else
+    for (const snippet of bundle.snippets) {
+      lines.push(`### ${snippet.file}:${snippet.startLine}-${snippet.endLine}`);
+      lines.push("");
+      lines.push(`Reason: ${snippet.reason} (score: ${snippet.score})`);
+      lines.push("");
+      lines.push("```ts");
+      lines.push(snippet.content);
+      lines.push("```");
+      lines.push("");
+    }
+  return lines.join(`
+`);
+}
+function collectArtifacts(events) {
+  return events.filter((event) => event.kind.startsWith("release.") || event.kind.startsWith("deploy.") || event.kind === "build.summary").map((event) => ({
+    kind: event.kind,
+    path: typeof event.data?.artifact === "string" ? event.data.artifact : void 0,
+    version: typeof event.data?.version === "string" ? event.data.version : void 0,
+    message: event.message,
+    ts: event.ts
+  })).slice(-10).reverse();
+}
+async function collectSnippets(cwd, latestDiagnostic, report, events, rootCauses, options) {
+  const candidates = new Map, fileFrequency = new Map, latestIncident = report.incidents[0], topCause = rootCauses[0], focusRoute = topCause?.route ?? latestDiagnostic?.route ?? latestIncident?.route, focusRequestId = topCause?.key.startsWith("request:") ? topCause.key.slice(8) : [...events].reverse().find((event) => event.severity === "error" || event.kind === "request.error")?.requestId, focusTraceId = topCause?.key.startsWith("trace:") ? topCause.key.slice(6) : [...events].reverse().find((event) => event.severity === "error" || event.kind === "request.error")?.traceId;
+  for (const event of events)
+    if (event.file)
+      fileFrequency.set(event.file, (fileFrequency.get(event.file) ?? 0) + 1);
+  if (latestDiagnostic?.file)
+    candidates.set(latestDiagnostic.file, {
+      line: latestDiagnostic.line,
+      reason: latestDiagnostic.code ? `latest diagnostic ${latestDiagnostic.code}` : "latest diagnostic",
+      score: 100
+    });
+  for (const incident of report.incidents) {
+    if (!incident.file)
+      continue;
+    const score = 60 + (fileFrequency.get(incident.file) ?? 0) * 5 + (incident.code ? 10 : 0), existing = candidates.get(incident.file);
+    if (!existing || score > existing.score)
+      candidates.set(incident.file, {
+        line: incident.line,
+        reason: incident.code ? `incident ${incident.code}` : incident.kind,
+        score
+      });
+  }
+  for (const event of events.filter((entry) => entry.severity === "error" || entry.kind === "request.error")) {
+    if (!event.file)
+      continue;
+    let score = (event.severity === "error" ? 40 : 20) + (fileFrequency.get(event.file) ?? 0) * 5;
+    if (focusRequestId && event.requestId === focusRequestId)
+      score += 20;
+    if (focusTraceId && event.traceId === focusTraceId)
+      score += 20;
+    const existing = candidates.get(event.file);
+    if (!existing || score > existing.score)
+      candidates.set(event.file, {
+        line: event.line,
+        reason: event.kind,
+        score
+      });
+  }
+  for (const cause of rootCauses) {
+    if (cause.file) {
+      const existing = candidates.get(cause.file);
+      if (!existing || cause.score > existing.score)
+        candidates.set(cause.file, {
+          line: latestDiagnostic?.file === cause.file ? latestDiagnostic.line : void 0,
+          reason: `root cause ${cause.key}`,
+          score: cause.score
+        });
+    }
+    if (cause.route)
+      for (const candidate of inferRouteFiles(cause.route)) {
+        const score = cause.score - (candidate.isLayout ? 8 : 0), existing = candidates.get(candidate.file);
+        if (!existing || score > existing.score)
+          candidates.set(candidate.file, {
+            line: 1,
+            reason: `root cause ${cause.key}`,
+            score
+          });
+      }
+  }
+  if (focusRoute)
+    for (const candidate of inferRouteFiles(focusRoute)) {
+      const score = 55 + (fileFrequency.get(candidate.file) ?? 0) * 5 + (candidate.isLayout ? 5 : 0), existing = candidates.get(candidate.file);
+      if (!existing || score > existing.score)
+        candidates.set(candidate.file, {
+          line: 1,
+          reason: candidate.reason,
+          score
+        });
+    }
+  const snippets = [], ranked = [...candidates.entries()].sort((a, b) => b[1].score - a[1].score).slice(0, options.maxSnippets);
+  for (const [file, meta] of ranked) {
+    const snippet = await readSnippet(cwd, file, meta.line, meta.reason, meta.score, options.snippetRadius);
+    if (snippet)
+      snippets.push(snippet);
+  }
+  return snippets;
+}
+function buildRootCauseRanking(report, latestDiagnostic, events) {
+  const causes = report.incidentClusters.map((cluster) => {
+    let score = cluster.count * 30;
+    if (cluster.traceId)
+      score += 25;
+    if (cluster.requestId)
+      score += 20;
+    if (cluster.file)
+      score += 15;
+    if (cluster.route)
+      score += 10;
+    if (latestDiagnostic?.file && cluster.file === latestDiagnostic.file)
+      score += 40;
+    if (latestDiagnostic?.route && cluster.route === latestDiagnostic.route)
+      score += 25;
+    if (cluster.codes.length > 0)
+      score += 10;
+    if (events.some((event) => event.traceId && cluster.traceId && event.traceId === cluster.traceId && event.kind === "request.error"))
+      score += 10;
+    return {
+      key: cluster.key,
+      score,
+      kind: cluster.kind,
+      route: cluster.route,
+      file: cluster.file,
+      latestTs: cluster.latestTs,
+      reasons: [
+        cluster.traceId ? "shared trace" : "",
+        cluster.requestId ? "shared request" : "",
+        cluster.file ? "file-locality" : "",
+        cluster.route ? "route-locality" : "",
+        cluster.count > 1 ? `repeated x${cluster.count}` : ""
+      ].filter(Boolean)
+    };
+  });
+  if (latestDiagnostic?.file && !causes.some((cause) => cause.file === latestDiagnostic.file))
+    causes.push({
+      key: `diagnostic:${latestDiagnostic.code ?? "latest"}`,
+      score: 120,
+      kind: "diagnostic.issue",
+      file: latestDiagnostic.file,
+      route: latestDiagnostic.route,
+      latestTs: new Date().toISOString(),
+      reasons: ["latest diagnostic"]
+    });
+  return causes.sort((a, b) => b.score - a.score).slice(0, 8);
+}
+async function readSnippet(cwd, file, line, reason, score, radius) {
+  const path = isAbsolute(file) ? file : join(cwd, file);
+  let content;
+  try {
+    content = await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.split(`
+`), focus = Math.max(1, Math.min(line ?? 1, lines.length)), startLine = Math.max(1, focus - radius), endLine = Math.min(lines.length, focus + radius);
+  return {
+    file,
+    startLine,
+    endLine,
+    reason,
+    score,
+    content: lines.slice(startLine - 1, endLine).join(`
+`)
+  };
+}
+function inferRouteFiles(route) {
+  const segments = (route === "/" ? "" : route.replace(/^\/+/, "")).split("/").filter(Boolean), files = [];
+  if (segments.length === 0) {
+    files.push({ file: "routes/index.tsx", reason: "focus route /" });
+    files.push({ file: "routes/_layout.tsx", reason: "root layout for focus route", isLayout: !0 });
+    return files;
+  }
+  const routePath = segments.join("/");
+  files.push({ file: `routes/${routePath}.tsx`, reason: `focus route ${route}` });
+  files.push({ file: `routes/${routePath}/index.tsx`, reason: `focus route ${route} index` });
+  files.push({ file: "routes/_layout.tsx", reason: "root layout for focus route", isLayout: !0 });
+  for (let i = 1;i <= segments.length; i++)
+    files.push({
+      file: `routes/${segments.slice(0, i).join("/")}/_layout.tsx`,
+      reason: `layout for ${route}`,
+      isLayout: !0
+    });
+  return dedupe(files);
+}
+function dedupe(files) {
+  const seen = new Set, unique = [];
+  for (const file of files) {
+    if (seen.has(file.file))
+      continue;
+    seen.add(file.file);
+    unique.push(file);
+  }
+  return unique;
+}

package/dist-pkg/ai/contracts.d.ts

@@ -0,0 +1 @@
+export declare const GORSEE_AI_CONTEXT_SCHEMA_VERSION = "1.0";

package/dist-pkg/ai/contracts.js

@@ -0,0 +1 @@
+export const GORSEE_AI_CONTEXT_SCHEMA_VERSION = "1.0";

package/dist-pkg/ai/ide.d.ts

@@ -0,0 +1,37 @@
+import { type AIContextPacket } from "./summary.js";
+import { type AIStorePaths } from "./store.js";
+export interface IDEProjectionPaths {
+    diagnosticsPath: string;
+    eventsPath: string;
+    contextPath: string;
+}
+export interface IDEProjection {
+    schemaVersion: string;
+    updatedAt: string;
+    diagnostics: Array<{
+        code?: string;
+        message: string;
+        severity: string;
+        file?: string;
+        line?: number;
+        route?: string;
+    }>;
+    recentEvents: Array<{
+        kind: string;
+        severity: string;
+        message: string;
+        ts: string;
+        route?: string;
+        file?: string;
+        line?: number;
+        artifact?: string;
+        version?: string;
+    }>;
+    artifactRegressions: AIContextPacket["artifactRegressions"];
+    context: AIContextPacket;
+}
+export declare function resolveIDEProjectionPaths(cwd: string): IDEProjectionPaths;
+export declare function buildIDEProjection(storePaths: AIStorePaths, options?: {
+    limit?: number;
+}): Promise<IDEProjection>;
+export declare function writeIDEProjection(projectionPaths: IDEProjectionPaths, projection: IDEProjection): Promise<void>;

package/dist-pkg/ai/ide.js

@@ -0,0 +1,56 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { createAIContextPacket, renderAIContextMarkdown } from "./summary.js";
+import { buildAIHealthReport, readAIDiagnosticsSnapshot, readAIEvents, readReactiveTraceArtifact } from "./store.js";
+import { GORSEE_AI_CONTEXT_SCHEMA_VERSION } from "./contracts.js";
+export function resolveIDEProjectionPaths(cwd) {
+  const base = join(cwd, ".gorsee", "ide");
+  return {
+    diagnosticsPath: join(base, "diagnostics.json"),
+    eventsPath: join(base, "events.json"),
+    contextPath: join(base, "context.md")
+  };
+}
+export async function buildIDEProjection(storePaths, options = {}) {
+  const events = await readAIEvents(storePaths.eventsPath, { limit: options.limit ?? 100 }), diagnosticsSnapshot = await readAIDiagnosticsSnapshot(storePaths.diagnosticsPath), reactiveTrace = await readReactiveTraceArtifact(storePaths.reactiveTracePath), report = await buildAIHealthReport(storePaths, { limit: options.limit ?? 200 }), context = createAIContextPacket(report, events, diagnosticsSnapshot?.latest, reactiveTrace);
+  return {
+    schemaVersion: GORSEE_AI_CONTEXT_SCHEMA_VERSION,
+    updatedAt: new Date().toISOString(),
+    diagnostics: diagnosticsSnapshot?.latest ? [{
+      code: diagnosticsSnapshot.latest.code,
+      message: diagnosticsSnapshot.latest.message ?? "",
+      severity: diagnosticsSnapshot.latest.severity ?? "error",
+      file: diagnosticsSnapshot.latest.file,
+      line: diagnosticsSnapshot.latest.line,
+      route: diagnosticsSnapshot.latest.route
+    }] : [],
+    recentEvents: events.slice(-20).reverse().map((event) => ({
+      kind: event.kind,
+      severity: event.severity,
+      message: event.message,
+      ts: event.ts,
+      route: event.route,
+      file: event.file,
+      line: event.line,
+      artifact: typeof event.data?.artifact === "string" ? event.data.artifact : void 0,
+      version: typeof event.data?.version === "string" ? event.data.version : void 0
+    })),
+    artifactRegressions: context.artifactRegressions,
+    context
+  };
+}
+export async function writeIDEProjection(projectionPaths, projection) {
+  await mkdir(dirname(projectionPaths.diagnosticsPath), { recursive: !0 });
+  await writeFile(projectionPaths.diagnosticsPath, JSON.stringify({
+    schemaVersion: projection.schemaVersion,
+    updatedAt: projection.updatedAt,
+    diagnostics: projection.diagnostics
+  }, null, 2), "utf-8");
+  await writeFile(projectionPaths.eventsPath, JSON.stringify({
+    schemaVersion: projection.schemaVersion,
+    updatedAt: projection.updatedAt,
+    events: projection.recentEvents,
+    artifactRegressions: projection.artifactRegressions
+  }, null, 2), "utf-8");
+  await writeFile(projectionPaths.contextPath, renderAIContextMarkdown(projection.context), "utf-8");
+}

package/dist-pkg/ai/index.d.ts

@@ -0,0 +1,85 @@
+import { type AISessionPackConfig } from "./session-pack.js";
+export { GORSEE_AI_CONTEXT_SCHEMA_VERSION, } from "./contracts.js";
+export { writeArtifactFailurePack, writeArtifactLifecycleEvent, writeArtifactSuccessPack, runArtifactLifecycleStep, type ArtifactLifecycleEventInput, } from "./artifact-lifecycle.js";
+export { createAIBridgeHandler, createAIBridgeServer, type AIBridgeHandler, type AIBridgeServer, type AIBridgeServerOptions, type AIBridgeSnapshot, } from "./bridge.js";
+export { buildAIHealthReport, readAIDiagnosticsSnapshot, readReactiveTraceArtifact, readAIEvents, resolveAIStorePaths, type AIHealthReport, type AIStorePaths, } from "./store.js";
+export { createAIMCPServer, createLineReader, type AIMCPServerOptions, } from "./mcp.js";
+export { createAIContextPacket, renderAIContextMarkdown, type AIContextPacket, } from "./summary.js";
+export { buildAIContextBundle, renderAIContextBundleMarkdown, type AIContextBundle, type AIContextSnippet, } from "./bundle.js";
+export { buildIDEProjection, resolveIDEProjectionPaths, writeIDEProjection, type IDEProjection, type IDEProjectionPaths, } from "./ide.js";
+export { createIDEProjectionWatcher, type IDEProjectionWatcher, type IDEProjectionWatcherOptions, } from "./watch.js";
+export { resolveAISessionPackConfig, resolveAISessionPackPaths, shouldGenerateAISessionPack, writeAISessionPack, type AISessionPackConfig, type AISessionPackPaths, } from "./session-pack.js";
+export type AIEventSeverity = "debug" | "info" | "warn" | "error";
+export type AIEventSource = "runtime" | "build" | "cli" | "check" | "deploy" | "dev" | "log";
+export interface AITraceContext {
+    requestId?: string;
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+}
+export interface AIDiagnostic {
+    code: string;
+    message: string;
+    severity: Exclude<AIEventSeverity, "debug">;
+    source: AIEventSource;
+    file?: string;
+    line?: number;
+    route?: string;
+    fix?: string;
+    ts: string;
+}
+export interface AIEvent {
+    id: string;
+    kind: string;
+    severity: AIEventSeverity;
+    ts: string;
+    source: AIEventSource;
+    message: string;
+    route?: string;
+    requestId?: string;
+    traceId?: string;
+    spanId?: string;
+    parentSpanId?: string;
+    phase?: string;
+    code?: string;
+    durationMs?: number;
+    file?: string;
+    line?: number;
+    tags?: string[];
+    data?: Record<string, unknown>;
+}
+export interface AIBridgeConfig {
+    url: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    events?: string[];
+}
+export interface AIObservabilityConfig {
+    enabled?: boolean;
+    jsonlPath?: string;
+    diagnosticsPath?: string;
+    redactKeys?: string[];
+    sessionId?: string;
+    bridge?: AIBridgeConfig;
+    sessionPack?: AISessionPackConfig;
+}
+export declare function configureAIObservability(config?: AIObservabilityConfig): void;
+export declare function getAIObservabilityConfig(): AIObservabilityConfig;
+export declare function isAIObservabilityEnabled(): boolean;
+export declare function emitAIEvent(input: Omit<AIEvent, "id" | "ts"> & {
+    ts?: string;
+    id?: string;
+}): Promise<void>;
+export declare function emitAIDiagnostic(input: Omit<AIDiagnostic, "ts"> & {
+    ts?: string;
+    requestId?: string;
+    traceId?: string;
+    spanId?: string;
+}): Promise<void>;
+export declare function createTraceIds(parent?: Partial<AITraceContext>): AITraceContext;
+export declare function runWithAITrace<T>(input: Omit<AIEvent, "id" | "ts" | "kind"> & {
+    kind: string;
+    trace?: Partial<AITraceContext>;
+}, fn: (trace: AITraceContext) => Promise<T>): Promise<T>;
+export declare function resolveAIObservabilityConfig(cwd: string, config?: AIObservabilityConfig): AIObservabilityConfig;
+export declare function __resetAIObservability(): void;