@neurcode/action 0.2.1

package/src/verify-mode.ts

@@ -0,0 +1,84 @@
+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;
+}
+
+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.record) args.push('--record');
+  return args;
+}
+
+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

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  buildVerifyArgs,
+  getVerifyFallbackDecision,
+  isMissingPlanVerificationFailure,
+} from '../src/verify-mode';
+
+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('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
+  );
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "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"]
+}
+