@smartergpt/lexrunner 1.0.0 → 1.2.1

package/src/frames/types.ts

@@ -1,258 +0,0 @@
-/**
- * Execution Frame Types
- *
- * Types for capturing workflow execution as Frames for memory integration.
- * Implements AX-005: Frame emission for core workflows.
- *
- * AX Principle: Memory Is a Feature
- */
-
-import { z } from "zod";
-
-/**
- * Frame outcome status
- */
-export type FrameOutcome = "success" | "failure" | "partial";
-
-/**
- * Frame type for workflow classification
- */
-export type FrameType = "execution" | "merge-weave" | "gate" | "procedure";
-
-/**
- * Execution Frame metadata schema
- */
-export const ExecutionFrameMetadataSchema = z.object({
-  /** Duration in milliseconds */
-  duration_ms: z.number().optional(),
-  /** Number of conflicts resolved during merge-weave */
-  conflicts_resolved: z.number().optional(),
-  /** List of gates that passed */
-  gates_passed: z.array(z.string()).optional(),
-  /** List of gates that failed */
-  gates_failed: z.array(z.string()).optional(),
-  /** Artifacts produced */
-  artifacts: z.array(z.string()).optional(),
-  /** Error message if applicable */
-  error: z.string().optional(),
-  /** Exit code if applicable */
-  exit_code: z.number().optional(),
-  /** Run ID for correlation */
-  run_id: z.string().optional(),
-  /** Plan hash for idempotency */
-  plan_hash: z.string().optional(),
-  /** Turn Cost tracking data */
-  turn_cost: z
-    .object({
-      /** Turn Cost components */
-      components: z.object({
-        latencyMs: z.number(),
-        contextResetTokens: z.number(),
-        renegotiationCount: z.number(),
-        tokenBloat: z.number(),
-        attentionSwitchCount: z.number(),
-      }),
-      /** Weighted score */
-      weightedScore: z.number(),
-      /** Number of events recorded */
-      eventCount: z.number(),
-      /** Prior run score for comparison */
-      priorRunScore: z.number().optional(),
-      /** Improvement percentage */
-      improvement: z.string().optional(),
-    })
-    .optional(),
-  /** Tier metrics for governance (Claim 3.4) */
-  tier_metrics: z
-    .object({
-      totalTasks: z.number(),
-      byTier: z.object({
-        senior: z.number(),
-        mid: z.number(),
-        junior: z.number(),
-      }),
-      escalations: z.number(),
-      mismatches: z.number(),
-      tierMatchRate: z.number(),
-      escalationRate: z.number(),
-    })
-    .optional(),
-  /** Constraint attributions (LR-TSF-001) */
-  governed_by: z
-    .array(
-      z.object({
-        /** Constraint identifier */
-        constraintId: z.string(),
-        /** Source of the constraint */
-        source: z.enum(["baseline", "persona", "learned"]),
-        /** Action that was governed */
-        action: z.string(),
-      })
-    )
-    .optional(),
-});
-
-export type ExecutionFrameMetadata = z.infer<typeof ExecutionFrameMetadataSchema>;
-
-/**
- * Execution Frame schema
- *
- * Represents what was attempted, scope touched, outcome, and recommended next steps.
- */
-export const ExecutionFrameSchema = z.object({
-  /** Frame type for classification */
-  type: z.enum(["execution", "merge-weave", "gate", "procedure"]),
-  /** Unique reference point (e.g., "merge-weave-2025-12-01-abc123") */
-  reference_point: z.string(),
-  /** Summary of what was attempted */
-  summary_caption: z.string(),
-  /** PR numbers or scope touched */
-  module_scope: z.array(z.string()),
-  /** Keywords for searchability */
-  keywords: z.array(z.string()),
-  /** Outcome of the execution */
-  outcome: z.enum(["success", "failure", "partial"]),
-  /** Recommended next steps */
-  next_actions: z.array(z.string()),
-  /** Additional metadata */
-  metadata: ExecutionFrameMetadataSchema.optional(),
-});
-
-export type ExecutionFrame = z.infer<typeof ExecutionFrameSchema>;
-
-/**
- * Input for emitting a merge-weave completion Frame
- */
-export interface MergeWeaveFrameInput {
-  /** Run ID for correlation */
-  runId: string;
-  /** PRs that were merged */
-  mergedPRs: string[];
-  /** Number of conflicts resolved */
-  conflictsResolved: number;
-  /** Gates that passed */
-  gatesPassed: string[];
-  /** Gates that failed (if any) */
-  gatesFailed?: string[];
-  /** Duration in milliseconds */
-  durationMs: number;
-  /** Outcome of the merge-weave */
-  outcome: FrameOutcome;
-  /** Target branch */
-  targetBranch: string;
-  /** Error message if failed */
-  error?: string;
-  /** Plan hash for idempotency */
-  planHash?: string;
-  /** Turn Cost tracking data */
-  turnCost?: {
-    components: {
-      latencyMs: number;
-      contextResetTokens: number;
-      renegotiationCount: number;
-      tokenBloat: number;
-      attentionSwitchCount: number;
-    };
-    weightedScore: number;
-    eventCount: number;
-    priorRunScore?: number;
-    improvement?: string;
-  };
-  /** Tier metrics for governance (Claim 3.4) */
-  tierMetrics?: {
-    totalTasks: number;
-    byTier: {
-      senior: number;
-      mid: number;
-      junior: number;
-    };
-    escalations: number;
-    mismatches: number;
-    tierMatchRate: number;
-    escalationRate: number;
-  };
-  /** Constraint attributions (LR-TSF-001) */
-  governedBy?: Array<{
-    constraintId: string;
-    source: "baseline" | "persona" | "learned";
-    action: string;
-  }>;
-}
-
-/**
- * Input for emitting an executor run Frame
- */
-export interface ExecutorFrameInput {
-  /** Run ID for correlation */
-  runId: string;
-  /** Procedure that was executed */
-  procedure: string;
-  /** Module scope touched */
-  moduleScope: string[];
-  /** Duration in milliseconds */
-  durationMs: number;
-  /** Outcome of the execution */
-  outcome: FrameOutcome;
-  /** Next recommended action */
-  nextAction: string;
-  /** Artifacts produced */
-  artifacts?: string[];
-  /** Error message if failed */
-  error?: string;
-}
-
-/**
- * Input for emitting a gate execution Frame
- */
-export interface GateFrameInput {
-  /** Run ID for correlation */
-  runId: string;
-  /** Gate name */
-  gateName: string;
-  /** Item/node that the gate ran for */
-  itemName: string;
-  /** Duration in milliseconds */
-  durationMs: number;
-  /** Outcome of the gate */
-  outcome: FrameOutcome;
-  /** Exit code */
-  exitCode?: number;
-  /** Artifacts collected */
-  artifacts?: string[];
-  /** Error message if failed */
-  error?: string;
-}
-
-/**
- * Result of Frame emission
- */
-export interface FrameEmitResult {
-  /** Whether the Frame was emitted successfully */
-  success: boolean;
-  /** The emitted Frame (if successful) */
-  frame?: ExecutionFrame;
-  /** Frame ID (if stored via Lex) */
-  frameId?: string;
-  /** Error message (if failed) */
-  error?: string;
-}
-
-/**
- * Validate an execution frame
- */
-export function validateExecutionFrame(frame: unknown): ExecutionFrame {
-  return ExecutionFrameSchema.parse(frame);
-}
-
-/**
- * Safely validate an execution frame
- */
-export function safeValidateExecutionFrame(
-  frame: unknown
-): { success: true; data: ExecutionFrame } | { success: false; error: z.ZodError } {
-  const result = ExecutionFrameSchema.safeParse(frame);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  return { success: false, error: result.error };
-}

package/src/gates/checkRunConverter.ts

@@ -1,91 +0,0 @@
-/**
- * Convert GitHub check runs to gate results
- */
-
-import type { GitHubCheckRun } from "../github/types.js";
-import type { GateResult } from "../schema.js";
-import type { GateMappingConfig } from "../schema/gateMapping.js";
-import { mapCheckNameToGate } from "../schema/gateMapping.js";
-
-/**
- * Convert a GitHub check run to a gate result
- */
-export function convertCheckRunToGateResult(
-  check: GitHubCheckRun,
-  config: GateMappingConfig
-): GateResult | null {
-  // Map check name to gate name
-  const gateName = mapCheckNameToGate(check.name, config);
-  if (!gateName) {
-    // No mapping found, skip this check
-    return null;
-  }
-
-  // Only process completed checks
-  if (check.status !== "completed") {
-    return null;
-  }
-
-  // Map conclusion to gate status
-  let status: "pass" | "fail" | "skipped";
-  switch (check.conclusion) {
-    case "success":
-      status = "pass";
-      break;
-    case "skipped":
-    case "neutral":
-      status = "skipped";
-      break;
-    case "failure":
-    case "timed_out":
-    case "action_required":
-    case "cancelled":
-    default:
-      status = "fail";
-      break;
-  }
-
-  // Calculate duration if both timestamps are available
-  let duration: number | undefined;
-  if (check.started_at && check.completed_at) {
-    const started = new Date(check.started_at).getTime();
-    const completed = new Date(check.completed_at).getTime();
-    duration = completed - started;
-  }
-
-  return {
-    gate: gateName,
-    status,
-    exitCode: status === "pass" ? 0 : 1,
-    duration,
-    stdout: `GitHub check: ${check.name}\nStatus: ${check.status}\nConclusion: ${check.conclusion || "unknown"}`,
-    stderr: status === "fail" ? `Check failed: ${check.name}` : "",
-    artifacts: [check.html_url],
-    attempts: 1,
-    lastAttempt: check.completed_at || new Date().toISOString(),
-  };
-}
-
-/**
- * Convert multiple GitHub check runs to gate results
- */
-export function convertCheckRunsToGateResults(
-  checks: GitHubCheckRun[],
-  config: GateMappingConfig
-): GateResult[] {
-  const results: GateResult[] = [];
-  const seenGates = new Set<string>();
-
-  for (const check of checks) {
-    const result = convertCheckRunToGateResult(check, config);
-    if (result) {
-      // Only include the first result for each gate (in case of duplicates)
-      if (!seenGates.has(result.gate)) {
-        results.push(result);
-        seenGates.add(result.gate);
-      }
-    }
-  }
-
-  return results;
-}

package/src/gates/test/adapters/errors.ts

@@ -1,32 +0,0 @@
-/**
- * Adapter-specific errors (ADR-009)
- */
-
-/**
- * Thrown when no adapter can be found for the given name or content
- */
-export class AdapterNotFoundError extends Error {
-  constructor(
-    message: string,
-    public readonly suggestions: string[] = []
-  ) {
-    super(message);
-    this.name = "AdapterNotFoundError";
-  }
-}
-
-/**
- * Thrown when an adapter fails to parse input
- *
- * Preserves raw input for debugging and auditability
- */
-export class AdapterParseError extends Error {
-  constructor(
-    message: string,
-    public readonly adapterName: string,
-    public readonly raw: string | Buffer
-  ) {
-    super(message);
-    this.name = "AdapterParseError";
-  }
-}

package/src/gates/test/adapters/index.ts

@@ -1,36 +0,0 @@
-/**
- * TestAdapter system - Interface, Registry, and Errors (ADR-009)
- *
- * @see docs/adr/ADR-009-ax-test-output-adapters.md
- */
-
-export type { TestAdapter, AdapterInfo } from "./interface.js";
-export { AdapterNotFoundError, AdapterParseError } from "./errors.js";
-export {
-  registerAdapter,
-  getAdapter,
-  detectAdapter,
-  listAdapters,
-  requireAdapter,
-  requireDetectedAdapter,
-  clearAdapters,
-  getAdapterCount,
-} from "./registry.js";
-
-// Adapter implementations
-export { vitestJsonAdapter } from "./vitest-json.js";
-export { jestJsonAdapter } from "./jest-json.js";
-export { junitXmlAdapter } from "./junit-xml.js";
-
-// Auto-register built-in adapters on import
-import { registerAdapter as _register, getAdapterCount } from "./registry.js";
-import { vitestJsonAdapter } from "./vitest-json.js";
-import { jestJsonAdapter } from "./jest-json.js";
-import { junitXmlAdapter } from "./junit-xml.js";
-
-// Only register if not already registered (avoids duplicate registration)
-if (getAdapterCount() === 0) {
-  _register(vitestJsonAdapter);
-  _register(jestJsonAdapter);
-  _register(junitXmlAdapter);
-}

package/src/gates/test/adapters/interface.ts

@@ -1,63 +0,0 @@
-/**
- * TestAdapter Interface (ADR-009)
- *
- * Defines the contract for test output adapters that normalize
- * runner-specific formats into AXTestResult.
- *
- * @see docs/adr/ADR-009-ax-test-output-adapters.md
- */
-
-import type { AXTestResult } from "../schema.js";
-
-/**
- * Test output adapter interface
- *
- * Adapters convert runner-specific test output (JSON, XML, TAP, etc.)
- * into the standardized AXTestResult format.
- *
- * Naming convention: {runner}-{format} for runner-specific adapters,
- * or {format}-{type} for universal formats (e.g., "vitest-json", "junit-xml")
- */
-export interface TestAdapter {
-  /**
-   * Adapter name following convention: {runner}-{format} or {format}-{type}
-   * Examples: "vitest-json", "jest-json", "junit-xml", "node-tap", "pytest-json"
-   */
-  name: string;
-
-  /**
-   * Adapter version (semver)
-   */
-  version: string;
-
-  /**
-   * File extensions this adapter handles (e.g., [".json", ".xml"])
-   */
-  extensions: string[];
-
-  /**
-   * Content-based detection for auto-discovery
-   *
-   * @param content - Raw file content or test output
-   * @returns true if this adapter can parse the content
-   */
-  detect(content: string): boolean;
-
-  /**
-   * Parse raw test output into normalized AXTestResult
-   *
-   * @param input - Raw test output (string or Buffer)
-   * @returns Normalized AXTestResult with failures, summary, and nextActions
-   * @throws AdapterParseError on parse failure (preserves raw input)
-   */
-  parse(input: string | Buffer): AXTestResult;
-}
-
-/**
- * Adapter information for discovery/listing
- */
-export interface AdapterInfo {
-  name: string;
-  version: string;
-  extensions: string[];
-}