@neurcode/action 0.2.2 → 0.3.0-rc.6

package/src/runtime-compat.ts

@@ -1,201 +0,0 @@
-import {
-  CLI_JSON_CONTRACT_VERSION,
-  getMinimumCompatiblePeerVersion,
-  isSemverAtLeast,
-  parseCliCompatJsonPayload,
-  RUNTIME_COMPATIBILITY_CONTRACT_ID,
-  RUNTIME_COMPATIBILITY_CONTRACT_VERSION,
-  RuntimeComponent,
-  RuntimeMinimumPeerVersions,
-} from '@neurcode-ai/contracts';
-
-export interface ParsedComponentCompatibility {
-  source: 'cli' | 'api';
-  contractId: string;
-  runtimeContractVersion: string;
-  cliJsonContractVersion: string;
-  component: RuntimeComponent;
-  componentVersion: string;
-  minimumPeerVersions: RuntimeMinimumPeerVersions;
-}
-
-function asRecord(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    throw new Error(`${label}: expected object`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function asString(record: Record<string, unknown>, key: string, label: string): string {
-  const value = record[key];
-  if (typeof value !== 'string' || !value.trim()) {
-    throw new Error(`${label}: expected ${key}:string`);
-  }
-  return value.trim();
-}
-
-function asRuntimeComponent(value: string, label: string): RuntimeComponent {
-  if (value === 'cli' || value === 'action' || value === 'api') {
-    return value;
-  }
-  throw new Error(`${label}: expected component "cli" | "action" | "api"`);
-}
-
-function parseMinimumPeerVersions(value: unknown, label: string): RuntimeMinimumPeerVersions {
-  if (value === undefined || value === null) return {};
-  const record = asRecord(value, `${label}.minimumPeerVersions`);
-  const next: RuntimeMinimumPeerVersions = {};
-  for (const component of ['cli', 'action', 'api'] as const) {
-    const item = record[component];
-    if (item === undefined) continue;
-    if (typeof item !== 'string' || !item.trim()) {
-      throw new Error(`${label}.minimumPeerVersions: expected ${component}:string`);
-    }
-    next[component] = item.trim();
-  }
-  return next;
-}
-
-function parseDescriptor(value: unknown, label: string): Omit<ParsedComponentCompatibility, 'source'> {
-  const record = asRecord(value, label);
-  return {
-    contractId: asString(record, 'contractId', label),
-    runtimeContractVersion: asString(record, 'runtimeContractVersion', label),
-    cliJsonContractVersion: asString(record, 'cliJsonContractVersion', label),
-    component: asRuntimeComponent(asString(record, 'component', label), label),
-    componentVersion: asString(record, 'componentVersion', label),
-    minimumPeerVersions: parseMinimumPeerVersions(record.minimumPeerVersions, label),
-  };
-}
-
-export function parseCliCompatibilityPayload(value: unknown): ParsedComponentCompatibility {
-  const parsed = parseCliCompatJsonPayload(value, 'action-cli-compat');
-  if (parsed.success !== true) {
-    throw new Error('action-cli-compat: success=false');
-  }
-  const descriptor = parseDescriptor(parsed.compatibility, 'action-cli-compat.compatibility');
-  return {
-    source: 'cli',
-    ...descriptor,
-  };
-}
-
-export function parseApiHealthCompatibilityPayload(value: unknown): ParsedComponentCompatibility | null {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    return null;
-  }
-  const record = value as Record<string, unknown>;
-  if (!record.compatibility) {
-    return null;
-  }
-  const descriptor = parseDescriptor(record.compatibility, 'action-api-compat.compatibility');
-  return {
-    source: 'api',
-    ...descriptor,
-  };
-}
-
-function validateVersionMinimum(
-  label: string,
-  actual: string,
-  required: string | undefined,
-  errors: string[]
-): void {
-  if (!required) return;
-  const isCompatible = isSemverAtLeast(actual, required);
-  if (isCompatible === null) {
-    errors.push(`${label}: unable to compare versions (actual=${actual}, required=${required}).`);
-    return;
-  }
-  if (!isCompatible) {
-    errors.push(`${label}: actual=${actual} is below required=${required}.`);
-  }
-}
-
-function validateContractEnvelope(
-  descriptor: ParsedComponentCompatibility,
-  expectedComponent: RuntimeComponent,
-  errors: string[]
-): void {
-  if (descriptor.component !== expectedComponent) {
-    errors.push(
-      `${descriptor.source} compatibility payload expected component=${expectedComponent} but received ${descriptor.component}.`
-    );
-  }
-  if (descriptor.contractId !== RUNTIME_COMPATIBILITY_CONTRACT_ID) {
-    errors.push(
-      `${descriptor.source} compatibility payload has unexpected contractId=${descriptor.contractId} (expected ${RUNTIME_COMPATIBILITY_CONTRACT_ID}).`
-    );
-  }
-  if (descriptor.runtimeContractVersion !== RUNTIME_COMPATIBILITY_CONTRACT_VERSION) {
-    errors.push(
-      `${descriptor.source} compatibility payload has runtimeContractVersion=${descriptor.runtimeContractVersion} (expected ${RUNTIME_COMPATIBILITY_CONTRACT_VERSION}).`
-    );
-  }
-  if (descriptor.cliJsonContractVersion !== CLI_JSON_CONTRACT_VERSION) {
-    errors.push(
-      `${descriptor.source} compatibility payload has cliJsonContractVersion=${descriptor.cliJsonContractVersion} (expected ${CLI_JSON_CONTRACT_VERSION}).`
-    );
-  }
-}
-
-export function validateActionHandshake(input: {
-  actionVersion: string;
-  cliCompatibility: ParsedComponentCompatibility;
-  apiCompatibility?: ParsedComponentCompatibility | null;
-  requireApiCompatibility?: boolean;
-}): string[] {
-  const errors: string[] = [];
-  const { actionVersion, cliCompatibility } = input;
-  const apiCompatibility = input.apiCompatibility || null;
-  const requireApiCompatibility = input.requireApiCompatibility === true;
-
-  validateContractEnvelope(cliCompatibility, 'cli', errors);
-  validateVersionMinimum(
-    'CLI version required by action',
-    cliCompatibility.componentVersion,
-    getMinimumCompatiblePeerVersion('action', 'cli'),
-    errors
-  );
-  validateVersionMinimum(
-    'Action version required by CLI payload',
-    actionVersion,
-    cliCompatibility.minimumPeerVersions.action,
-    errors
-  );
-
-  if (!apiCompatibility) {
-    if (requireApiCompatibility) {
-      errors.push('API compatibility payload missing while API compatibility handshake is required.');
-    }
-    return errors;
-  }
-
-  validateContractEnvelope(apiCompatibility, 'api', errors);
-  validateVersionMinimum(
-    'API version required by action',
-    apiCompatibility.componentVersion,
-    getMinimumCompatiblePeerVersion('action', 'api'),
-    errors
-  );
-  validateVersionMinimum(
-    'Action version required by API payload',
-    actionVersion,
-    apiCompatibility.minimumPeerVersions.action,
-    errors
-  );
-  validateVersionMinimum(
-    'CLI version required by API payload',
-    cliCompatibility.componentVersion,
-    apiCompatibility.minimumPeerVersions.cli,
-    errors
-  );
-  validateVersionMinimum(
-    'API version required by CLI payload',
-    apiCompatibility.componentVersion,
-    cliCompatibility.minimumPeerVersions.api,
-    errors
-  );
-
-  return errors;
-}

package/src/verify-mode.ts

@@ -1,116 +0,0 @@
-export type VerifyFallbackReason =
-  | 'missing_plan_context'
-  | 'verify_succeeded'
-  | 'already_policy_only'
-  | 'explicit_plan_id'
-  | 'not_missing_plan_failure';
-
-export interface VerifyFallbackDecision {
-  shouldRetryPolicyOnly: boolean;
-  reason: VerifyFallbackReason;
-}
-
-export interface VerifyFallbackDecisionInput {
-  verifyExitCode: number;
-  policyOnlyRequested: boolean;
-  hasExplicitPlanId: boolean;
-  verifyOutput: string;
-}
-
-export interface VerifyArgsInput {
-  baseRef: string;
-  planId?: string;
-  projectId?: string;
-  policyOnly: boolean;
-  record: boolean;
-  compiledPolicyPath?: string;
-  changeContractPath?: string;
-  enforceChangeContract: boolean;
-  strictArtifacts?: boolean;
-}
-
-export interface EnterpriseEnforcementInput {
-  enterpriseMode: boolean;
-  verifyPolicyOnly: boolean;
-  enforceChangeContract?: boolean;
-  enforceStrictVerification?: boolean;
-}
-
-export interface EnterpriseEnforcementDecision {
-  enforceChangeContract: boolean;
-  enforceStrictVerification: boolean;
-}
-
-const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
-
-const MISSING_PLAN_VERIFY_PATTERNS = [
-  'plan id is required in strict mode',
-  'run "neurcode plan" first',
-  'pass --plan-id',
-  '"mode": "plan_required"',
-  '"mode":"plan_required"',
-  'missing plan context',
-  'plan context missing',
-  'no approved plan context',
-];
-
-function stripAnsi(value: string): string {
-  return value.replace(ANSI_PATTERN, '');
-}
-
-export function isMissingPlanVerificationFailure(output: string): boolean {
-  const normalized = stripAnsi(output).toLowerCase();
-  return MISSING_PLAN_VERIFY_PATTERNS.some((pattern) => normalized.includes(pattern));
-}
-
-export function buildVerifyArgs(input: VerifyArgsInput): string[] {
-  const args = ['verify', '--json', '--base', input.baseRef];
-  if (input.policyOnly) {
-    args.push('--policy-only');
-  } else if (input.planId) {
-    args.push('--plan-id', input.planId);
-  }
-  if (input.projectId) args.push('--project-id', input.projectId);
-  if (input.compiledPolicyPath) args.push('--compiled-policy', input.compiledPolicyPath);
-  if (input.changeContractPath) args.push('--change-contract', input.changeContractPath);
-  if (input.enforceChangeContract) args.push('--enforce-change-contract');
-  if (input.strictArtifacts) args.push('--strict-artifacts');
-  if (input.record) args.push('--record');
-  return args;
-}
-
-export function resolveEnterpriseEnforcement(
-  input: EnterpriseEnforcementInput
-): EnterpriseEnforcementDecision {
-  const enforceChangeContract =
-    typeof input.enforceChangeContract === 'boolean'
-      ? input.enforceChangeContract
-      : (input.enterpriseMode && !input.verifyPolicyOnly);
-  const enforceStrictVerification =
-    typeof input.enforceStrictVerification === 'boolean'
-      ? input.enforceStrictVerification
-      : input.enterpriseMode;
-
-  return {
-    enforceChangeContract,
-    enforceStrictVerification,
-  };
-}
-
-export function getVerifyFallbackDecision(
-  input: VerifyFallbackDecisionInput
-): VerifyFallbackDecision {
-  if (input.verifyExitCode === 0) {
-    return { shouldRetryPolicyOnly: false, reason: 'verify_succeeded' };
-  }
-  if (input.policyOnlyRequested) {
-    return { shouldRetryPolicyOnly: false, reason: 'already_policy_only' };
-  }
-  if (input.hasExplicitPlanId) {
-    return { shouldRetryPolicyOnly: false, reason: 'explicit_plan_id' };
-  }
-  if (isMissingPlanVerificationFailure(input.verifyOutput)) {
-    return { shouldRetryPolicyOnly: true, reason: 'missing_plan_context' };
-  }
-  return { shouldRetryPolicyOnly: false, reason: 'not_missing_plan_failure' };
-}

package/tests/reliability-contract.test.ts

@@ -1,214 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import {
-  buildVerifyArgs,
-  getVerifyFallbackDecision,
-  isMissingPlanVerificationFailure,
-  resolveEnterpriseEnforcement,
-} from '../src/verify-mode';
-import {
-  parseApiHealthCompatibilityPayload,
-  parseCliCompatibilityPayload,
-  validateActionHandshake,
-} from '../src/runtime-compat';
-
-test('verify args remain plan-aware when no plan_id is provided', () => {
-  const args = buildVerifyArgs({
-    baseRef: 'origin/main',
-    policyOnly: false,
-    record: true,
-    enforceChangeContract: false,
-  });
-
-  assert.deepEqual(args, ['verify', '--json', '--base', 'origin/main', '--record']);
-  assert.equal(args.includes('--policy-only'), false);
-  assert.equal(args.includes('--plan-id'), false);
-});
-
-test('verify args enforce explicit plan_id when provided', () => {
-  const args = buildVerifyArgs({
-    baseRef: 'origin/main',
-    policyOnly: false,
-    record: true,
-    planId: 'plan_123',
-    enforceChangeContract: false,
-  });
-
-  assert.deepEqual(args, [
-    'verify',
-    '--json',
-    '--base',
-    'origin/main',
-    '--plan-id',
-    'plan_123',
-    '--record',
-  ]);
-});
-
-test('verify args include strict artifact enforcement when requested', () => {
-  const args = buildVerifyArgs({
-    baseRef: 'origin/main',
-    policyOnly: false,
-    record: false,
-    planId: 'plan_123',
-    enforceChangeContract: true,
-    strictArtifacts: true,
-  });
-
-  assert.equal(args.includes('--strict-artifacts'), true);
-  assert.equal(args.includes('--enforce-change-contract'), true);
-});
-
-test('fallback decision retries policy-only when plan context is missing and no explicit plan_id exists', () => {
-  const decision = getVerifyFallbackDecision({
-    verifyExitCode: 2,
-    policyOnlyRequested: false,
-    hasExplicitPlanId: false,
-    verifyOutput:
-      'verification failed: plan id is required in strict mode. run "neurcode plan" first.',
-  });
-
-  assert.equal(decision.shouldRetryPolicyOnly, true);
-  assert.equal(decision.reason, 'missing_plan_context');
-});
-
-test('fallback decision does not retry policy-only when explicit plan_id was supplied', () => {
-  const decision = getVerifyFallbackDecision({
-    verifyExitCode: 2,
-    policyOnlyRequested: false,
-    hasExplicitPlanId: true,
-    verifyOutput:
-      'verification failed: plan id is required in strict mode. run "neurcode plan" first.',
-  });
-
-  assert.equal(decision.shouldRetryPolicyOnly, false);
-  assert.equal(decision.reason, 'explicit_plan_id');
-});
-
-test('missing-plan matcher recognizes canonical strict-mode errors', () => {
-  assert.equal(
-    isMissingPlanVerificationFailure('Error: plan context missing for current diff'),
-    true
-  );
-  assert.equal(
-    isMissingPlanVerificationFailure('policy violations found in changed files'),
-    false
-  );
-});
-
-test('enterprise mode auto-enables strict and change-contract enforcement for plan-aware runs', () => {
-  const decision = resolveEnterpriseEnforcement({
-    enterpriseMode: true,
-    verifyPolicyOnly: false,
-  });
-
-  assert.equal(decision.enforceChangeContract, true);
-  assert.equal(decision.enforceStrictVerification, true);
-});
-
-test('enterprise auto mode relaxes change-contract hard-fail for policy-only runs', () => {
-  const decision = resolveEnterpriseEnforcement({
-    enterpriseMode: true,
-    verifyPolicyOnly: true,
-  });
-
-  assert.equal(decision.enforceChangeContract, false);
-  assert.equal(decision.enforceStrictVerification, true);
-});
-
-test('explicit enforcement inputs override enterprise auto behavior', () => {
-  const decision = resolveEnterpriseEnforcement({
-    enterpriseMode: true,
-    verifyPolicyOnly: true,
-    enforceChangeContract: false,
-    enforceStrictVerification: true,
-  });
-
-  assert.equal(decision.enforceChangeContract, false);
-  assert.equal(decision.enforceStrictVerification, true);
-});
-
-test('compatibility parser accepts valid CLI compat payload', () => {
-  const parsed = parseCliCompatibilityPayload({
-    success: true,
-    component: 'cli',
-    componentVersion: '0.9.35',
-    timestamp: new Date().toISOString(),
-    compatibility: {
-      contractId: 'neurcode-runtime-compatibility',
-      runtimeContractVersion: '2026-04-04',
-      cliJsonContractVersion: '2026-04-04',
-      component: 'cli',
-      componentVersion: '0.9.35',
-      minimumPeerVersions: {
-        action: '0.2.1',
-        api: '0.2.0',
-      },
-    },
-  });
-
-  assert.equal(parsed.component, 'cli');
-  assert.equal(parsed.componentVersion, '0.9.35');
-});
-
-test('compatibility handshake reports violation when CLI is below required minimum', () => {
-  const errors = validateActionHandshake({
-    actionVersion: '0.2.1',
-    cliCompatibility: {
-      source: 'cli',
-      contractId: 'neurcode-runtime-compatibility',
-      runtimeContractVersion: '2026-04-04',
-      cliJsonContractVersion: '2026-04-04',
-      component: 'cli',
-      componentVersion: '0.9.10',
-      minimumPeerVersions: {
-        action: '0.2.1',
-        api: '0.2.0',
-      },
-    },
-  });
-
-  assert.equal(errors.length > 0, true);
-  assert.equal(errors.some((item) => item.includes('CLI version required by action')), true);
-});
-
-test('compatibility handshake validates API payload when present', () => {
-  const apiCompatibility = parseApiHealthCompatibilityPayload({
-    status: 'ok',
-    version: '0.2.0',
-    compatibility: {
-      contractId: 'neurcode-runtime-compatibility',
-      runtimeContractVersion: '2026-04-04',
-      cliJsonContractVersion: '2026-04-04',
-      component: 'api',
-      componentVersion: '0.2.0',
-      minimumPeerVersions: {
-        cli: '0.9.35',
-        action: '0.2.1',
-      },
-    },
-  });
-
-  assert.ok(apiCompatibility);
-
-  const errors = validateActionHandshake({
-    actionVersion: '0.2.1',
-    cliCompatibility: {
-      source: 'cli',
-      contractId: 'neurcode-runtime-compatibility',
-      runtimeContractVersion: '2026-04-04',
-      cliJsonContractVersion: '2026-04-04',
-      component: 'cli',
-      componentVersion: '0.9.35',
-      minimumPeerVersions: {
-        action: '0.2.1',
-        api: '0.2.0',
-      },
-    },
-    apiCompatibility,
-    requireApiCompatibility: true,
-  });
-
-  assert.deepEqual(errors, []);
-});

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": false,
-    "sourceMap": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}
-