@vitronai/themis 0.1.0-beta.0 → 0.1.0-beta.1

package/globals.d.ts

@@ -1,4 +1,21 @@
-import type { Describe, Expect, Fn, Hook, Intent, MockControl, MockModule, SpyOn, Test } from './index';
+import type {
+  Cleanup,
+  Describe,
+  Expect,
+  FireEventApi,
+  Fn,
+  Hook,
+  Intent,
+  MockControl,
+  MockModule,
+  Render,
+  ScreenApi,
+  SpyOn,
+  Test,
+  FetchMock,
+  FlushMicrotasks,
+  WaitFor
+} from './index';
 
 declare global {
   var describe: Describe;
@@ -17,6 +34,19 @@ declare global {
   var clearAllMocks: MockControl;
   var resetAllMocks: MockControl;
   var restoreAllMocks: MockControl;
+  var render: Render;
+  var screen: ScreenApi;
+  var fireEvent: FireEventApi;
+  var waitFor: WaitFor;
+  var cleanup: Cleanup;
+  var useFakeTimers: () => void;
+  var useRealTimers: () => void;
+  var advanceTimersByTime: (ms: number) => void;
+  var runAllTimers: () => void;
+  var flushMicrotasks: FlushMicrotasks;
+  var mockFetch: (handlerOrResponse: unknown) => FetchMock;
+  var restoreFetch: () => void;
+  var resetFetchMocks: () => void;
 }
 
 export {};

package/index.d.ts

@@ -62,6 +62,7 @@ export interface RunResult {
   files: FileResult[];
   summary: RunSummary;
   stability?: StabilityReport;
+  artifacts?: RunArtifacts;
 }
 
 export type TestEnvironment = 'node' | 'jsdom';
@@ -75,7 +76,8 @@ export interface RunOptions {
   environment?: TestEnvironment;
   setupFiles?: string[];
   tsconfigPath?: string | null;
-  updateSnapshots?: boolean;
+  isolation?: 'worker' | 'in-process';
+  cache?: boolean;
 }
 
 export interface ThemisConfig {
@@ -86,6 +88,364 @@ export interface ThemisConfig {
   environment: TestEnvironment;
   setupFiles: string[];
   tsconfigPath: string | null;
+  testIgnore: string[];
+}
+
+export interface MigrationResult {
+  source: 'jest' | 'vitest';
+  configPath: string;
+  setupPath: string;
+  compatPath: string;
+  packageJsonPath: string | null;
+  packageUpdated: boolean;
+  rewriteImports: boolean;
+  rewrittenFiles: string[];
+  reportPath: string;
+  report: {
+    schema: 'themis.migration.report.v1';
+    source: 'jest' | 'vitest';
+    createdAt: string;
+    summary: {
+      matchedFiles: number;
+      jestGlobals: number;
+      vitest: number;
+      testingLibraryReact: number;
+      rewrittenFiles: number;
+      rewrittenImports: number;
+    };
+    files: Array<{
+      file: string;
+      imports: string[];
+    }>;
+    rewrites: string[];
+    nextActions: string[];
+  };
+}
+
+export interface MigrationOptions {
+  rewriteImports?: boolean;
+}
+
+export interface GenerateOptions {
+  targetDir?: string;
+  outputDir?: string;
+  force?: boolean;
+  strict?: boolean;
+  writeHints?: boolean;
+  plan?: boolean;
+  review?: boolean;
+  update?: boolean;
+  clean?: boolean;
+  changed?: boolean;
+  failOnSkips?: boolean;
+  failOnConflicts?: boolean;
+  requireConfidence?: string | null;
+  files?: string[] | string;
+  scenario?: string | null;
+  minConfidence?: string | null;
+  matchSource?: string | null;
+  matchExport?: string | null;
+  include?: string | null;
+  exclude?: string | null;
+}
+
+export interface GenerateSkippedFile {
+  file: string;
+  reason: string;
+  stage: string;
+}
+
+export interface GenerateScenarioSummary {
+  kind: string;
+  confidence: string;
+  exports: string[];
+  caseCount: number;
+}
+
+export interface GenerateEntrySummary {
+  action: string;
+  sourceFile: string;
+  testFile: string | null;
+  moduleKind: string;
+  confidence: string;
+  exactExports: boolean;
+  exportNames: string[];
+  hintsFile: string | null;
+  sourceHash: string | null;
+  scenarios: GenerateScenarioSummary[];
+  reason: string | null;
+}
+
+export interface GenerateFilterSummary {
+  plan: boolean;
+  changed: boolean;
+  files: string[];
+  scenario: string | null;
+  minConfidence: string | null;
+  matchSource: string | null;
+  matchExport: string | null;
+  include: string | null;
+  exclude: string | null;
+}
+
+export interface GenerateArtifacts {
+  generateMap: string;
+  helperFile: string;
+  generateResult: string;
+  generateHandoff: string;
+  generateBacklog: string;
+}
+
+export interface GenerateHintFiles {
+  created: string[];
+  updated: string[];
+  unchanged: string[];
+}
+
+export interface RunArtifactPaths {
+  lastRun: string;
+  failedTests: string;
+  runDiff: string;
+  runHistory: string;
+  fixHandoff: string;
+}
+
+export interface RunComparison {
+  status: 'baseline' | 'changed';
+  previousRunId: string;
+  previousRunAt: string;
+  currentRunAt: string;
+  delta: RunSummary;
+  newFailures: string[];
+  resolvedFailures: string[];
+}
+
+export interface RunArtifacts {
+  runId: string;
+  comparison: RunComparison;
+  paths: RunArtifactPaths;
+}
+
+export interface GenerateGateFailure {
+  code: string;
+  count: number;
+  message: string;
+}
+
+export interface GenerateGateSummary {
+  strict: boolean;
+  failOnSkips: boolean;
+  failOnConflicts: boolean;
+  requireConfidence: string | null;
+  failed: boolean;
+  failures: GenerateGateFailure[];
+}
+
+export interface GenerateBacklogItem {
+  type: string;
+  severity: 'warning' | 'error';
+  sourceFile: string;
+  testFile: string | null;
+  moduleKind: string | null;
+  confidence: string | null;
+  stage: string | null;
+  hintsFile: string | null;
+  reason: string;
+  suggestedAction: string;
+  suggestedCommand: string | null;
+}
+
+export interface GenerateBacklogSummary {
+  total: number;
+  errors: number;
+  warnings: number;
+  skipped: number;
+  conflicts: number;
+  confidence: number;
+}
+
+export interface GenerateBacklog {
+  summary: GenerateBacklogSummary;
+  items: GenerateBacklogItem[];
+}
+
+export interface GeneratePromptTarget {
+  action: string;
+  sourceFile: string;
+  testFile: string | null;
+  moduleKind: string;
+  confidence: string;
+  scenarios: string[];
+}
+
+export interface GeneratePromptReady {
+  summary: string;
+  targets: GeneratePromptTarget[];
+  unresolved: GenerateBacklogItem[];
+  nextActions: string[];
+  prompt: string;
+}
+
+export type FixHandoffCategory = 'source-drift' | 'generated-contract-failure';
+
+export interface FixHandoffItem {
+  file: string;
+  name: string;
+  fullName: string;
+  message: string;
+  testFile: string;
+  sourceFile: string;
+  moduleKind: string | null;
+  confidence: string | null;
+  scenarios: string[];
+  hintsFile: string | null;
+  category: FixHandoffCategory;
+  failureCount: number;
+  failedTests: string[];
+  suggestedAction: string;
+  suggestedCommand: string | null;
+  repairStrategy: string;
+  candidateFiles: string[];
+  autofixCommand: string | null;
+}
+
+export interface FixHandoffPayload {
+  schema: 'themis.fix.handoff.v1';
+  runId: string;
+  createdAt: string;
+  summary: {
+    totalFailures: number;
+    generatedFailures: number;
+    staleSources: number;
+    contractFailures: number;
+  };
+  artifacts: {
+    failedTests: string;
+    generateMap: string;
+    generateBacklog: string;
+    fixHandoff: string;
+  };
+  items: FixHandoffItem[];
+  nextActions: string[];
+}
+
+export interface GeneratePayload {
+  schema: 'themis.generate.result.v1';
+  mode: {
+    review: boolean;
+    update: boolean;
+    clean: boolean;
+    changed: boolean;
+    plan: boolean;
+    writeHints: boolean;
+  };
+  source: {
+    targetDir: string;
+    outputDir: string;
+  };
+  filters: GenerateFilterSummary;
+  gates: GenerateGateSummary;
+  summary: {
+    scanned: number;
+    generated: number;
+    created: number;
+    updated: number;
+    unchanged: number;
+    removed: number;
+    skipped: number;
+    conflicts: number;
+  };
+  scannedFiles: string[];
+  generatedFiles: string[];
+  removedFiles: string[];
+  skippedFiles: GenerateSkippedFile[];
+  conflictFiles: string[];
+  hintFiles: GenerateHintFiles;
+  entries: GenerateEntrySummary[];
+  backlog: GenerateBacklog;
+  artifacts: GenerateArtifacts;
+  promptReady: GeneratePromptReady;
+  hints: {
+    runTests: string;
+    plan: string;
+    review: string;
+    updateOnly: string;
+    clean: string;
+    changed: string;
+    strict: string;
+    writeHints: string;
+    fileTarget: string;
+  };
+}
+
+export interface GenerateBacklogPayload {
+  schema: 'themis.generate.backlog.v1';
+  source: {
+    targetDir: string;
+    outputDir: string;
+  };
+  filters: GenerateFilterSummary;
+  gates: GenerateGateSummary;
+  summary: GenerateBacklogSummary;
+  items: GenerateBacklogItem[];
+}
+
+export interface GenerateHandoffPayload {
+  schema: 'themis.generate.handoff.v1';
+  source: {
+    targetDir: string;
+    outputDir: string;
+  };
+  filters: GenerateFilterSummary;
+  gates: GenerateGateSummary;
+  summary: GeneratePayload['summary'];
+  artifacts: {
+    generateMap: string;
+    generateResult: string;
+    generateBacklog: string;
+  };
+  hintFiles: GenerateHintFiles;
+  targets: GeneratePromptTarget[];
+  unresolved: GenerateBacklogItem[];
+  backlog: GenerateBacklogSummary;
+  nextActions: string[];
+  prompt: string;
+}
+
+export interface GenerateSummary {
+  targetDir: string;
+  outputDir: string;
+  helperFile: string;
+  mapFile: string;
+  scannedFiles: string[];
+  generatedFiles: string[];
+  removedFiles: string[];
+  skippedFiles: GenerateSkippedFile[];
+  createdFiles: string[];
+  updatedFiles: string[];
+  unchangedFiles: string[];
+  cleanedFiles: string[];
+  conflictFiles: string[];
+  entries: GenerateEntrySummary[];
+  plan: boolean;
+  review: boolean;
+  update: boolean;
+  clean: boolean;
+  changed: boolean;
+  writeHints: boolean;
+  filters: GenerateFilterSummary;
+  gateOptions: {
+    strict: boolean;
+    failOnSkips: boolean;
+    failOnConflicts: boolean;
+    requireConfidence: string | null;
+  };
+  gates: GenerateGateSummary;
+  hintFiles: GenerateHintFiles;
+  backlog: GenerateBacklog;
+  artifacts: GenerateArtifacts;
+  prompt: string;
+  helperRemoved: boolean;
 }
 
 export function main(argv: string[]): Promise<void>;
@@ -94,7 +454,17 @@ export function runTests(files: string[], options?: RunOptions): Promise<RunResu
 export function discoverTests(cwd: string, config: ThemisConfig): string[];
 export function loadConfig(cwd: string): ThemisConfig;
 export function initConfig(cwd: string): void;
+export function runMigrate(cwd: string, framework: 'jest' | 'vitest', options?: MigrationOptions): MigrationResult;
 export const DEFAULT_CONFIG: ThemisConfig;
+export function generateTestsFromSource(cwd: string, options?: GenerateOptions): GenerateSummary;
+export function buildGeneratePayload(summary: GenerateSummary, cwd?: string): GeneratePayload;
+export function buildGenerateBacklogPayload(summary: GenerateSummary, cwd?: string): GenerateBacklogPayload;
+export function buildGenerateHandoff(payload: GeneratePayload): GenerateHandoffPayload;
+export function writeGenerateArtifacts(summary: GenerateSummary, cwd?: string): {
+  payload: GeneratePayload;
+  handoff: GenerateHandoffPayload;
+  backlog: GenerateBacklogPayload;
+};
 
 export interface MockResult {
   type: 'return' | 'throw';
@@ -134,7 +504,9 @@ export interface ExpectMatchers<TReceived = unknown> {
   toHaveBeenCalled(): void;
   toHaveBeenCalledTimes(expected: number): void;
   toHaveBeenCalledWith(...expectedArgs: unknown[]): void;
-  toMatchSnapshot(snapshotName?: string): void;
+  toHaveTextContent(expected: string): void;
+  toHaveAttribute(name: string, expectedValue?: string): void;
+  toBeInTheDocument(): void;
 }
 
 export type Expect = <TReceived = unknown>(received: TReceived) => ExpectMatchers<TReceived>;
@@ -148,6 +520,37 @@ export type SpyOn = <TTarget extends Record<string, unknown>, TKey extends keyof
 ) => MockFunction<any[], any>;
 export type MockModule = (request: string, factoryOrExports?: unknown | (() => unknown)) => void;
 export type MockControl = () => void;
+export interface RenderResult {
+  container: HTMLElement;
+  rerender(nextInput: unknown): void;
+  unmount(): void;
+}
+export interface ScreenApi {
+  getByText(text: string): HTMLElement;
+  queryByText(text: string): HTMLElement | null;
+  getByRole(role: string, options?: { name?: string }): HTMLElement;
+  queryByRole(role: string, options?: { name?: string }): HTMLElement | null;
+  getByLabelText(labelText: string): HTMLElement;
+}
+export interface FireEventApi {
+  click(node: Node): Event;
+  change(node: Node, payload?: { target?: Record<string, unknown> }): Event;
+  input(node: Node, payload?: { target?: Record<string, unknown> }): Event;
+  submit(node: Node): Event;
+  keyDown(node: Node, payload?: { key?: string }): Event;
+}
+export type Render = (input: unknown, options?: { container?: HTMLElement }) => RenderResult;
+export type WaitFor = <T>(assertion: () => T | Promise<T>, options?: { timeout?: number; interval?: number }) => Promise<T>;
+export type Cleanup = () => void;
+export type FetchMock = MockFunction<any[], Promise<unknown>>;
+export type UseFakeTimers = () => void;
+export type UseRealTimers = () => void;
+export type AdvanceTimersByTime = (ms: number) => void;
+export type RunAllTimers = () => void;
+export type FlushMicrotasks = () => Promise<void>;
+export type MockFetch = (handlerOrResponse: unknown) => FetchMock;
+export type RestoreFetch = () => void;
+export type ResetFetchMocks = () => void;
 
 export type SuiteFn = () => void;
 export type TestFn = () => Awaitable<void>;

package/index.js

@@ -3,7 +3,15 @@ const { collectAndRun } = require('./src/runtime');
 const { runTests } = require('./src/runner');
 const { discoverTests } = require('./src/discovery');
 const { loadConfig, initConfig, DEFAULT_CONFIG } = require('./src/config');
+const { runMigrate } = require('./src/migrate');
 const { expect } = require('./src/expect');
+const {
+  generateTestsFromSource,
+  buildGeneratePayload,
+  buildGenerateBacklogPayload,
+  buildGenerateHandoff,
+  writeGenerateArtifacts
+} = require('./src/generate');
 
 module.exports = {
   main,
@@ -12,6 +20,12 @@ module.exports = {
   discoverTests,
   loadConfig,
   initConfig,
+  runMigrate,
   DEFAULT_CONFIG,
+  generateTestsFromSource,
+  buildGeneratePayload,
+  buildGenerateBacklogPayload,
+  buildGenerateHandoff,
+  writeGenerateArtifacts,
   expect
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitronai/themis",
-  "version": "0.1.0-beta.0",
+  "version": "0.1.0-beta.1",
   "description": "Intent-first unit test framework for AI agents in Node.js and TypeScript, powered by an AI verdict engine",
   "license": "MIT",
   "author": "Vitron AI",