@neurcode-ai/governance-runtime 0.1.3 → 0.1.4

package/src/index.ts

@@ -1,463 +0,0 @@
-export type PlanVerdict = 'PASS' | 'FAIL' | 'WARN';
-export {
-  compileDeterministicConstraints,
-  type DeterministicConstraintCompilation,
-  type DeterministicConstraintCompilationInput,
-  type DeterministicConstraintRule,
-  type DeterministicConstraintSource,
-} from './constraints';
-import { compileDeterministicConstraints, type DeterministicConstraintRule } from './constraints';
-
-export interface PlanFileScopeItem {
-  path: string;
-  action: string;
-}
-
-export interface PlanDiffLine {
-  type: 'context' | 'added' | 'removed';
-  content: string;
-  lineNumber?: number;
-}
-
-export interface PlanDiffHunk {
-  oldStart: number;
-  oldLines: number;
-  newStart: number;
-  newLines: number;
-  lines: PlanDiffLine[];
-}
-
-export interface PlanDiffFile {
-  path: string;
-  oldPath?: string;
-  changeType: 'add' | 'delete' | 'modify' | 'rename';
-  added: number;
-  removed: number;
-  hunks?: PlanDiffHunk[];
-}
-
-export interface PlanDiffStats {
-  totalAdded: number;
-  totalRemoved: number;
-  totalFiles: number;
-}
-
-export interface PlanVerificationInput {
-  planFiles: PlanFileScopeItem[];
-  changedFiles: PlanDiffFile[];
-  diffStats?: PlanDiffStats;
-  intentConstraints?: string;
-  policyRules?: string[];
-  extraConstraintRules?: DeterministicConstraintRule[];
-  fileContents?: Record<string, string>;
-}
-
-export interface PlanDiffSummary {
-  added: number;
-  removed: number;
-  files: Array<{
-    path: string;
-    oldPath?: string;
-    changeType: string;
-    added: number;
-    removed: number;
-    hunks: PlanDiffHunk[];
-  }>;
-  bloatFiles: string[];
-  plannedFilesModified: number;
-  totalPlannedFiles: number;
-}
-
-export interface PlanVerificationResult {
-  adherenceScore: number;
-  bloatCount: number;
-  bloatFiles: string[];
-  plannedFilesModified: number;
-  totalPlannedFiles: number;
-  scopeGuardPassed: boolean;
-  constraintViolations: string[];
-  verdict: PlanVerdict;
-  diffSummary: PlanDiffSummary;
-  message: string;
-}
-
-function normalizeRepoPath(pathValue: string): string {
-  return pathValue.replace(/\\/g, '/').replace(/^\.\//, '').trim();
-}
-
-export function extractPlannedFilePaths(planFiles: PlanFileScopeItem[]): string[] {
-  const plannedFilePaths = new Set<string>();
-
-  for (const file of planFiles) {
-    const normalizedPath = normalizeRepoPath(file.path);
-    if (!normalizedPath) {
-      continue;
-    }
-
-    if (file.action === 'MODIFY' || file.action === 'CREATE') {
-      plannedFilePaths.add(normalizedPath);
-    }
-  }
-
-  return Array.from(plannedFilePaths);
-}
-
-function detectConstraintViolations(
-  intentConstraints: string | undefined,
-  policyRules: string[] | undefined,
-  extraConstraintRules: DeterministicConstraintRule[] | undefined,
-  changedFiles: PlanDiffFile[],
-  fileContents?: Record<string, string>
-): string[] {
-  const compiled = compileDeterministicConstraints({
-    intentConstraints,
-    policyRules,
-  });
-
-  const rules = [
-    ...compiled.rules,
-    ...(extraConstraintRules || []),
-  ];
-
-  if (rules.length === 0) {
-    return [];
-  }
-
-  const violations: string[] = [];
-  const seenViolations = new Set<string>();
-  const normalizedFileContents: Record<string, string> = {};
-  for (const [path, content] of Object.entries(fileContents || {})) {
-    normalizedFileContents[normalizeRepoPath(path)] = content;
-  }
-
-  const pathMatchesRule = (rule: DeterministicConstraintRule, filePath: string): boolean => {
-    const include = rule.pathIncludes || [];
-    const exclude = rule.pathExcludes || [];
-    if (include.length > 0 && !include.some((pattern) => pattern.test(filePath))) {
-      return false;
-    }
-    if (exclude.length > 0 && exclude.some((pattern) => pattern.test(filePath))) {
-      return false;
-    }
-    return true;
-  };
-
-  const countMatches = (pattern: RegExp, input: string): number => {
-    if (!input) return 0;
-    const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
-    const re = new RegExp(pattern.source, flags);
-    let total = 0;
-    for (const _match of input.matchAll(re)) {
-      total += 1;
-    }
-    return total;
-  };
-
-  const addedLinesByPath = new Map<string, string>();
-  for (const file of changedFiles) {
-    const addedLines = (file.hunks || []).flatMap((hunk) =>
-      hunk.lines
-        .filter((line) => line.type === 'added')
-        .map((line) => line.content)
-    );
-    addedLinesByPath.set(file.path, addedLines.join('\n'));
-  }
-
-  const candidateRepoPaths = new Set<string>([
-    ...changedFiles.map((file) => file.path),
-    ...Object.keys(normalizedFileContents),
-  ]);
-
-  for (const rule of rules) {
-    if (rule.evaluationMode === 'signature_delta') {
-      for (const file of changedFiles) {
-        if (!pathMatchesRule(rule, file.path)) {
-          continue;
-        }
-        const addedSignatureLines = (file.hunks || []).flatMap((hunk) =>
-          hunk.lines
-            .filter((line) => line.type === 'added' && new RegExp(rule.pattern.source, rule.pattern.flags).test(line.content))
-            .map((line) => line.content)
-        );
-        const removedSignatureLines = (file.hunks || []).flatMap((hunk) =>
-          hunk.lines
-            .filter((line) => line.type === 'removed' && new RegExp(rule.pattern.source, rule.pattern.flags).test(line.content))
-            .map((line) => line.content)
-        );
-        const deltaCount = addedSignatureLines.length + removedSignatureLines.length;
-        if (deltaCount === 0) {
-          continue;
-        }
-        const violation =
-          `Exported API signature delta detected in ${file.path} ` +
-          `(added ${addedSignatureLines.length}, removed ${removedSignatureLines.length}, violates constraint: "${rule.displayName}")`;
-        if (!seenViolations.has(violation)) {
-          seenViolations.add(violation);
-          violations.push(violation);
-        }
-      }
-      continue;
-    }
-
-    const hasMatchBounds =
-      (typeof rule.maxMatchesPerFile === 'number' && Number.isFinite(rule.maxMatchesPerFile))
-      || (typeof rule.minMatchesPerFile === 'number' && Number.isFinite(rule.minMatchesPerFile));
-
-    if (rule.evaluationScope === 'repo' && hasMatchBounds) {
-      let repoMatchCount = 0;
-      let scannedPaths = 0;
-      for (const filePath of candidateRepoPaths) {
-        if (!pathMatchesRule(rule, filePath)) {
-          continue;
-        }
-        const fullContent = normalizedFileContents[filePath];
-        const addedFallback = addedLinesByPath.get(filePath) || '';
-        const haystack =
-          rule.evaluationMode === 'full_file' && typeof fullContent === 'string'
-            ? fullContent
-            : addedFallback;
-        if (!haystack) {
-          continue;
-        }
-        scannedPaths += 1;
-        repoMatchCount += countMatches(rule.pattern, haystack);
-      }
-
-      if (
-        typeof rule.maxMatchesPerFile === 'number'
-        && Number.isFinite(rule.maxMatchesPerFile)
-        && repoMatchCount > rule.maxMatchesPerFile
-      ) {
-        const violation =
-          `${rule.matchToken} matched ${repoMatchCount} times across repository scope ` +
-          `(limit ${rule.maxMatchesPerFile}, scanned ${scannedPaths} file(s), violates constraint: "${rule.displayName}")`;
-        if (!seenViolations.has(violation)) {
-          seenViolations.add(violation);
-          violations.push(violation);
-        }
-      }
-
-      if (
-        typeof rule.minMatchesPerFile === 'number'
-        && Number.isFinite(rule.minMatchesPerFile)
-        && repoMatchCount < rule.minMatchesPerFile
-      ) {
-        const violation =
-          `${rule.matchToken} matched ${repoMatchCount} times across repository scope ` +
-          `(minimum ${rule.minMatchesPerFile}, scanned ${scannedPaths} file(s), violates constraint: "${rule.displayName}")`;
-        if (!seenViolations.has(violation)) {
-          seenViolations.add(violation);
-          violations.push(violation);
-        }
-      }
-      continue;
-    }
-
-    for (const file of changedFiles) {
-      if (!pathMatchesRule(rule, file.path)) {
-        continue;
-      }
-      if (!file.hunks || file.hunks.length === 0) {
-        continue;
-      }
-
-      const addedLines = addedLinesByPath.get(file.path) || '';
-
-      if (hasMatchBounds) {
-        const fullContent = normalizedFileContents[file.path];
-        const haystack =
-          rule.evaluationMode === 'full_file' && typeof fullContent === 'string'
-            ? fullContent
-            : addedLines;
-        const matchCount = countMatches(rule.pattern, haystack);
-        if (
-          typeof rule.maxMatchesPerFile === 'number'
-          && Number.isFinite(rule.maxMatchesPerFile)
-          && matchCount > rule.maxMatchesPerFile
-        ) {
-          const violation =
-            `${rule.matchToken} matched ${matchCount} times in ${file.path} ` +
-            `(limit ${rule.maxMatchesPerFile}, violates constraint: "${rule.displayName}")`;
-          if (!seenViolations.has(violation)) {
-            seenViolations.add(violation);
-            violations.push(violation);
-          }
-        }
-        if (
-          typeof rule.minMatchesPerFile === 'number'
-          && Number.isFinite(rule.minMatchesPerFile)
-          && matchCount < rule.minMatchesPerFile
-        ) {
-          const violation =
-            `${rule.matchToken} matched ${matchCount} times in ${file.path} ` +
-            `(minimum ${rule.minMatchesPerFile}, violates constraint: "${rule.displayName}")`;
-          if (!seenViolations.has(violation)) {
-            seenViolations.add(violation);
-            violations.push(violation);
-          }
-        }
-        continue;
-      }
-
-      for (const hunk of file.hunks) {
-        for (const line of hunk.lines) {
-          if (line.type !== 'added') {
-            continue;
-          }
-          const pattern = new RegExp(rule.pattern.source, rule.pattern.flags);
-          if (!pattern.test(line.content)) {
-            continue;
-          }
-          const violation = `${rule.matchToken} found in ${file.path} (violates constraint: \"${rule.displayName}\")`;
-          if (seenViolations.has(violation)) {
-            continue;
-          }
-          seenViolations.add(violation);
-          violations.push(violation);
-        }
-      }
-    }
-  }
-
-  return violations;
-}
-
-export function resolvePlanVerdict(input: {
-  bloatCount: number;
-  adherenceScore: number;
-  totalPlannedFiles: number;
-  plannedFilesModified: number;
-  constraintViolations: string[];
-}): PlanVerdict {
-  if (input.constraintViolations.length > 0) {
-    return 'FAIL';
-  }
-
-  if (input.totalPlannedFiles === 0 && input.plannedFilesModified === 0) {
-    // 0/0 is treated as incomplete, not perfect adherence.
-    return 'FAIL';
-  }
-
-  if (input.bloatCount > 0 && input.adherenceScore < 50) {
-    return 'FAIL';
-  }
-
-  if (input.bloatCount > 0 || input.adherenceScore < 80) {
-    return 'WARN';
-  }
-
-  return 'PASS';
-}
-
-export function buildPlanVerificationMessage(result: Pick<
-  PlanVerificationResult,
-  'constraintViolations' | 'totalPlannedFiles' | 'plannedFilesModified' | 'verdict' | 'adherenceScore' | 'bloatCount'
->): string {
-  if (result.constraintViolations.length > 0) {
-    return `❌ Constraint violation: ${result.constraintViolations[0]}${result.constraintViolations.length > 1 ? ` (+${result.constraintViolations.length - 1} more)` : ''}`;
-  }
-
-  if (result.totalPlannedFiles === 0 && result.plannedFilesModified === 0) {
-    return '❌ Incomplete: No planned files to verify (0/0). Plan may be malformed.';
-  }
-
-  if (result.verdict === 'PASS') {
-    return `✅ Plan adherence: ${result.adherenceScore}% (${result.plannedFilesModified}/${result.totalPlannedFiles} planned files modified)`;
-  }
-
-  if (result.verdict === 'WARN') {
-    return `⚠️  Plan adherence: ${result.adherenceScore}% (${result.plannedFilesModified}/${result.totalPlannedFiles} planned files modified)${result.bloatCount > 0 ? `, ${result.bloatCount} unexpected file(s) changed` : ''}`;
-  }
-
-  return `❌ Plan adherence: ${result.adherenceScore}% (${result.plannedFilesModified}/${result.totalPlannedFiles} planned files modified), ${result.bloatCount} unexpected file(s) changed`;
-}
-
-export function evaluatePlanVerification(input: PlanVerificationInput): PlanVerificationResult {
-  const plannedFilePaths = extractPlannedFilePaths(input.planFiles);
-  const plannedSet = new Set(plannedFilePaths);
-
-  const normalizedChangedFiles = input.changedFiles.map((file) => ({
-    ...file,
-    path: normalizeRepoPath(file.path),
-    oldPath: file.oldPath ? normalizeRepoPath(file.oldPath) : undefined,
-    hunks: file.hunks || [],
-  }));
-
-  const changedFilePaths = Array.from(
-    new Set(
-      normalizedChangedFiles
-        .map((file) => file.path)
-        .filter(Boolean)
-    )
-  );
-  const changedSet = new Set(changedFilePaths);
-
-  const bloatFiles = changedFilePaths.filter((pathValue) => !plannedSet.has(pathValue));
-  const bloatCount = bloatFiles.length;
-
-  const totalPlannedFiles = plannedSet.size;
-  const plannedFilesModified = plannedFilePaths.filter((pathValue) => changedSet.has(pathValue)).length;
-  const adherenceScore = totalPlannedFiles > 0
-    ? Math.round((plannedFilesModified / totalPlannedFiles) * 100)
-    : 0;
-
-  const constraintViolations = detectConstraintViolations(
-    input.intentConstraints,
-    input.policyRules,
-    input.extraConstraintRules,
-    normalizedChangedFiles,
-    input.fileContents
-  );
-  const verdict = resolvePlanVerdict({
-    bloatCount,
-    adherenceScore,
-    totalPlannedFiles,
-    plannedFilesModified,
-    constraintViolations,
-  });
-
-  const totalAdded = input.diffStats
-    ? input.diffStats.totalAdded
-    : normalizedChangedFiles.reduce((sum, file) => sum + file.added, 0);
-  const totalRemoved = input.diffStats
-    ? input.diffStats.totalRemoved
-    : normalizedChangedFiles.reduce((sum, file) => sum + file.removed, 0);
-
-  const diffSummary: PlanDiffSummary = {
-    added: totalAdded,
-    removed: totalRemoved,
-    files: normalizedChangedFiles.map((file) => ({
-      path: file.path,
-      oldPath: file.oldPath,
-      changeType: file.changeType,
-      added: file.added,
-      removed: file.removed,
-      hunks: file.hunks || [],
-    })),
-    bloatFiles,
-    plannedFilesModified,
-    totalPlannedFiles,
-  };
-
-  const message = buildPlanVerificationMessage({
-    constraintViolations,
-    totalPlannedFiles,
-    plannedFilesModified,
-    verdict,
-    adherenceScore,
-    bloatCount,
-  });
-
-  return {
-    adherenceScore,
-    bloatCount,
-    bloatFiles,
-    plannedFilesModified,
-    totalPlannedFiles,
-    scopeGuardPassed: bloatCount === 0,
-    constraintViolations,
-    verdict,
-    diffSummary,
-    message,
-  };
-}

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": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
-}