@urielsh/prodify 0.1.2 → 0.1.3

package/src/scoring/scoring-engine.ts

@@ -0,0 +1,194 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { listFilesRecursive } from '../core/fs.js';
+import { normalizeRepoRelativePath } from '../core/paths.js';
+import type { ScoreBreakdown, ScoreSignals, ScoreSnapshot } from '../types.js';
+
+const SCORE_WEIGHTS: ScoreBreakdown = {
+  structure: 30,
+  maintainability: 30,
+  complexity: 20,
+  testability: 20
+};
+
+const CODE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.py', '.cs']);
+
+interface SourceFile {
+  path: string;
+  content: string;
+}
+
+function round(value: number): number {
+  return Math.round(value * 100) / 100;
+}
+
+function clamp(value: number, min = 0, max = 100): number {
+  return Math.max(min, Math.min(max, value));
+}
+
+function scoreInverse(value: number, ideal: number, tolerance: number): number {
+  if (value <= ideal) {
+    return 100;
+  }
+
+  return clamp(100 - (((value - ideal) / tolerance) * 100));
+}
+
+function extractImports(content: string): string[] {
+  return content
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('import ') || line.startsWith('export ') || line.includes('require('));
+}
+
+function extractDependencyDepth(imports: string[]): number {
+  const relativeImports = imports
+    .map((line) => /from\s+['"](.+?)['"]/.exec(line)?.[1] ?? /require\(['"](.+?)['"]\)/.exec(line)?.[1] ?? '')
+    .filter((specifier) => specifier.startsWith('./') || specifier.startsWith('../'));
+
+  if (relativeImports.length === 0) {
+    return 0;
+  }
+
+  return Math.max(...relativeImports.map((specifier) => specifier.split('/').filter((segment) => segment === '..').length));
+}
+
+function extractFunctionLengths(content: string): number[] {
+  const lines = content.replace(/\r\n/g, '\n').split('\n');
+  const lengths: number[] = [];
+  let captureDepth = 0;
+  let currentLength = 0;
+  let tracking = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const startsFunction = /^(export\s+)?(async\s+)?function\s+\w+/.test(trimmed)
+      || /^(export\s+)?const\s+\w+\s*=\s*(async\s*)?\(/.test(trimmed)
+      || /^(public\s+|private\s+|protected\s+)?(async\s+)?\w+\s*\(.*\)\s*\{?$/.test(trimmed);
+
+    if (startsFunction && trimmed.includes('{')) {
+      tracking = true;
+      currentLength = 1;
+      captureDepth = (trimmed.match(/\{/g) ?? []).length - (trimmed.match(/\}/g) ?? []).length;
+      if (captureDepth <= 0) {
+        lengths.push(currentLength);
+        tracking = false;
+        currentLength = 0;
+        captureDepth = 0;
+      }
+      continue;
+    }
+
+    if (!tracking) {
+      continue;
+    }
+
+    currentLength += 1;
+    captureDepth += (trimmed.match(/\{/g) ?? []).length;
+    captureDepth -= (trimmed.match(/\}/g) ?? []).length;
+    if (captureDepth <= 0) {
+      lengths.push(currentLength);
+      tracking = false;
+      currentLength = 0;
+      captureDepth = 0;
+    }
+  }
+
+  return lengths;
+}
+
+async function collectSourceFiles(repoRoot: string): Promise<SourceFile[]> {
+  const allFiles = await listFilesRecursive(repoRoot);
+  const sourceFiles: SourceFile[] = [];
+
+  for (const file of allFiles) {
+    const relativePath = normalizeRepoRelativePath(file.relativePath);
+    if (relativePath.startsWith('.git/')
+      || relativePath.startsWith('.prodify/')
+      || relativePath.startsWith('.agent/')
+      || relativePath.startsWith('.codex/')
+      || relativePath.startsWith('dist/')
+      || relativePath.startsWith('node_modules/')) {
+      continue;
+    }
+
+    if (!CODE_EXTENSIONS.has(path.extname(relativePath))) {
+      continue;
+    }
+
+    sourceFiles.push({
+      path: relativePath,
+      content: await fs.readFile(file.fullPath, 'utf8')
+    });
+  }
+
+  return sourceFiles.sort((left, right) => left.path.localeCompare(right.path));
+}
+
+function deriveSignals(sourceFiles: SourceFile[]): ScoreSignals {
+  const functionLengths = sourceFiles.flatMap((file) => extractFunctionLengths(file.content));
+  const allImports = sourceFiles.map((file) => extractImports(file.content));
+  const moduleCount = sourceFiles.length;
+  const averageFunctionLength = functionLengths.length === 0
+    ? 0
+    : functionLengths.reduce((sum, value) => sum + value, 0) / functionLengths.length;
+  const averageDirectoryDepth = moduleCount === 0
+    ? 0
+    : sourceFiles
+      .map((file) => path.posix.dirname(file.path))
+      .map((directory) => directory === '.' ? 0 : directory.split('/').length)
+      .reduce((sum, depth) => sum + depth, 0) / moduleCount;
+  const dependencyDepth = allImports.length === 0
+    ? 0
+    : Math.max(...allImports.map((imports) => extractDependencyDepth(imports)));
+  const averageImportsPerModule = moduleCount === 0
+    ? 0
+    : allImports.reduce((sum, imports) => sum + imports.length, 0) / moduleCount;
+  const testFiles = sourceFiles.filter((file) => file.path.startsWith('tests/') || /\.test\./.test(file.path)).length;
+  const sourceModules = Math.max(1, sourceFiles.filter((file) => file.path.startsWith('src/')).length);
+  const testFileRatio = testFiles / sourceModules;
+
+  return {
+    average_function_length: round(averageFunctionLength),
+    module_count: moduleCount,
+    average_directory_depth: round(averageDirectoryDepth),
+    dependency_depth: dependencyDepth,
+    average_imports_per_module: round(averageImportsPerModule),
+    test_file_ratio: round(testFileRatio)
+  };
+}
+
+function buildBreakdown(signals: ScoreSignals): ScoreBreakdown {
+  const structure = round(((clamp(signals.module_count * 5, 0, 60)) + clamp(signals.average_directory_depth * 15, 0, 40)));
+  const maintainability = round((scoreInverse(signals.average_function_length, 18, 40) * 0.7) + (scoreInverse(signals.average_imports_per_module, 4, 8) * 0.3));
+  const complexity = round((scoreInverse(signals.dependency_depth, 1, 5) * 0.6) + (scoreInverse(signals.average_imports_per_module, 4, 8) * 0.4));
+  const testability = round(clamp(signals.test_file_ratio * 100, 0, 100));
+
+  return {
+    structure: clamp(structure),
+    maintainability: clamp(maintainability),
+    complexity: clamp(complexity),
+    testability: clamp(testability)
+  };
+}
+
+export async function calculateRepositoryQuality(repoRoot: string): Promise<Pick<ScoreSnapshot, 'breakdown' | 'signals' | 'total_score' | 'max_score' | 'weights'>> {
+  const sourceFiles = await collectSourceFiles(repoRoot);
+  const signals = deriveSignals(sourceFiles);
+  const breakdown = buildBreakdown(signals);
+  const total = round(
+    (breakdown.structure * (SCORE_WEIGHTS.structure / 100))
+    + (breakdown.maintainability * (SCORE_WEIGHTS.maintainability / 100))
+    + (breakdown.complexity * (SCORE_WEIGHTS.complexity / 100))
+    + (breakdown.testability * (SCORE_WEIGHTS.testability / 100))
+  );
+
+  return {
+    breakdown,
+    signals,
+    total_score: total,
+    max_score: 100,
+    weights: SCORE_WEIGHTS
+  };
+}

package/src/types.ts

@@ -119,6 +119,34 @@ export interface StageSkillRouting {
   conditional_skills: StageSkillRoutingRule[];
 }
 
+export interface DiffValidationRules {
+  minimum_files_modified: number;
+  minimum_lines_changed: number;
+  must_create_files: boolean;
+  required_structural_changes: string[];
+}
+
+export interface StructuralChangeSummary {
+  new_directories: string[];
+  new_layer_directories: string[];
+  files_with_reduced_responsibility: string[];
+  new_modules: string[];
+  structural_change_flags: string[];
+}
+
+export interface DiffResult {
+  filesModified: number;
+  filesAdded: number;
+  filesDeleted: number;
+  linesAdded: number;
+  linesRemoved: number;
+  modifiedPaths: string[];
+  addedPaths: string[];
+  deletedPaths: string[];
+  formattingOnlyPaths: string[];
+  structuralChanges: StructuralChangeSummary;
+}
+
 export interface CompiledStageContract {
   schema_version: string;
   contract_version: string;
@@ -132,6 +160,9 @@ export interface CompiledStageContract {
   policy_rules: string[];
   success_criteria: string[];
   skill_routing: StageSkillRouting;
+  diff_validation_rules: DiffValidationRules;
+  min_impact_score: number;
+  enforce_plan_units: boolean;
 }
 
 export interface ContractSourceDocument {
@@ -163,6 +194,8 @@ export interface StageValidationResult {
   missing_artifacts: string[];
   warnings: string[];
   diagnostics: string[];
+  diff_result?: DiffResult;
+  impact_score_delta?: number;
 }
 
 export interface RuntimeFailureMetadata {
@@ -265,6 +298,7 @@ export interface StatusReport {
   bootstrapProfile: RuntimeProfileName;
   bootstrapPrompt: string;
   stageSkillResolution: StageSkillResolution | null;
+  scoreDelta: ScoreDelta | null;
   recommendedNextAction: string;
   presetMetadata: VersionMetadata;
 }
@@ -300,12 +334,31 @@ export interface ScoreMetric {
   details: string;
 }
 
+export interface ScoreBreakdown {
+  structure: number;
+  maintainability: number;
+  complexity: number;
+  testability: number;
+}
+
+export interface ScoreSignals {
+  average_function_length: number;
+  module_count: number;
+  average_directory_depth: number;
+  dependency_depth: number;
+  average_imports_per_module: number;
+  test_file_ratio: number;
+}
+
 export interface ScoreSnapshot {
   schema_version: string;
   kind: ScoreSnapshotKind;
   ecosystems: string[];
   total_score: number;
   max_score: number;
+  breakdown: ScoreBreakdown;
+  weights: ScoreBreakdown;
+  signals: ScoreSignals;
   metrics: ScoreMetric[];
 }
 
@@ -314,6 +367,8 @@ export interface ScoreDelta {
   baseline_score: number;
   final_score: number;
   delta: number;
+  min_impact_score?: number;
+  passed?: boolean;
 }
 
 export interface AgentSetupRecord {

package/tests/integration/cli-flows.test.js

@@ -91,6 +91,7 @@ test('status becomes the primary user-facing summary after init', async () => {
   assert.match(result.stdout, /Skills active: codebase-scanning/);
   assert.match(result.stdout, /Execution state: not bootstrapped/);
   assert.match(result.stdout, /Stage validation: not run yet/);
+  assert.match(result.stdout, /Impact score: not available/);
   assert.match(result.stdout, /Manual bootstrap: ready/);
   assert.match(result.stdout, /Bootstrap prompt: Read \.prodify\/AGENTS\.md/);
   assert.match(result.stdout, /Recommended next action: prodify setup-agent <agent>/);

package/tests/unit/diff-validator.test.js

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { captureRepoSnapshot, diffSnapshots } from '../../dist/core/diff-validator.js';
+import { createTempRepo } from './helpers.js';
+
+test('diff validator detects added modules, line changes, and structural improvements', async () => {
+  const repoRoot = await createTempRepo();
+  await fs.mkdir(path.join(repoRoot, 'src'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'src', 'routes.ts'), `export function routeUser() {\n  const user = loadUser();\n  return user;\n}\n`, 'utf8');
+
+  const before = await captureRepoSnapshot(repoRoot);
+
+  await fs.mkdir(path.join(repoRoot, 'src', 'services'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'src', 'routes.ts'), `import { loadUserService } from './services/user-service.js';\n\nexport function routeUser() {\n  return loadUserService();\n}\n`, 'utf8');
+  await fs.writeFile(path.join(repoRoot, 'src', 'services', 'user-service.ts'), `export function loadUserService() {\n  return loadUser();\n}\n`, 'utf8');
+
+  const after = await captureRepoSnapshot(repoRoot);
+  const diff = diffSnapshots(before, after);
+
+  assert.equal(diff.filesAdded, 1);
+  assert.equal(diff.filesModified, 1);
+  assert.match(diff.structuralChanges.structural_change_flags.join(','), /module-boundary-created/);
+  assert.match(diff.structuralChanges.structural_change_flags.join(','), /responsibility-reduced/);
+  assert.deepEqual(diff.structuralChanges.new_layer_directories, ['src/services']);
+});

package/tests/unit/scoring.test.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 
 import { runCli } from '../../dist/cli.js';
 import { bootstrapFlowState, startFlowExecution } from '../../dist/core/flow-state.js';
-import { readRuntimeState } from '../../dist/core/state.js';
+import { readRuntimeState, writeRuntimeState } from '../../dist/core/state.js';
 import { writeScoreDelta, writeScoreSnapshot } from '../../dist/scoring/model.js';
 import { createTempRepo, memoryStream } from './helpers.js';
 
@@ -58,8 +58,49 @@ test('baseline, final, and delta score artifacts are written under .prodify/metr
 
   assert.equal(typeof baseline.total_score, 'number');
   assert.equal(typeof final.total_score, 'number');
+  assert.equal(typeof baseline.breakdown.structure, 'number');
+  assert.equal(typeof final.signals.average_function_length, 'number');
   assert.equal(delta.delta, Number((final.total_score - baseline.total_score).toFixed(2)));
   await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'baseline.score.json'));
   await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'final.score.json'));
   await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'delta.json'));
 });
+
+test('runtime state writes refresh baseline and final scoring artifacts automatically', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const state = await readRuntimeState(repoRoot, {
+    presetMetadata: {
+      name: 'default',
+      version: '4.0.0',
+      schemaVersion: '4'
+    }
+  });
+
+  const bootstrapped = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  await writeRuntimeState(repoRoot, bootstrapped);
+
+  const finalState = startFlowExecution(bootstrapped);
+  finalState.runtime.current_state = 'validate_complete';
+  finalState.runtime.current_stage = 'validate';
+  finalState.runtime.current_task_id = '06-validate';
+  finalState.runtime.last_validation = {
+    stage: 'validate',
+    contract_version: '1.0.0',
+    passed: true,
+    violated_rules: [],
+    missing_artifacts: [],
+    warnings: [],
+    diagnostics: ['ok']
+  };
+  finalState.runtime.last_validation_result = 'pass';
+  await writeRuntimeState(repoRoot, finalState);
+
+  await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'baseline.score.json'));
+  await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'final.score.json'));
+  await fs.access(path.join(repoRoot, '.prodify', 'metrics', 'delta.json'));
+});

package/tests/unit/validation.test.js

@@ -6,7 +6,8 @@ import path from 'node:path';
 import { runCli } from '../../dist/cli.js';
 import { loadCompiledContract } from '../../dist/contracts/compiler.js';
 import { bootstrapFlowState, startFlowExecution } from '../../dist/core/flow-state.js';
-import { readRuntimeState } from '../../dist/core/state.js';
+import { diffAgainstRefactorBaseline } from '../../dist/core/diff-validator.js';
+import { readRuntimeState, writeRuntimeState } from '../../dist/core/state.js';
 import { validateStageOutputs } from '../../dist/core/validation.js';
 import { createTempRepo, memoryStream } from './helpers.js';
 
@@ -71,3 +72,80 @@ test('missing artifacts and forbidden writes fail contract validation determinis
   assert.match(result.violated_rules.map((issue) => issue.rule).join(','), /artifact\/missing/);
   assert.match(result.violated_rules.map((issue) => issue.rule).join(','), /writes\/forbidden/);
 });
+
+test('refactor validation enforces plan units, diff thresholds, and structural changes', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+  await fs.mkdir(path.join(repoRoot, 'src'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'src', 'legacy.ts'), `export function legacyFlow() {\n  const record = loadLegacy();\n  const normalized = normalizeLegacy(record);\n  const payload = buildLegacyPayload(normalized);\n  return payload;\n}\n`, 'utf8');
+
+  const state = await readRuntimeState(repoRoot, {
+    presetMetadata: {
+      name: 'default',
+      version: '4.0.0',
+      schemaVersion: '4'
+    }
+  });
+
+  const refactorState = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  refactorState.runtime.current_state = 'refactor_pending';
+  refactorState.runtime.current_stage = 'refactor';
+  refactorState.runtime.current_task_id = '05-refactor';
+  await writeRuntimeState(repoRoot, refactorState);
+
+  await fs.writeFile(path.join(repoRoot, '.prodify', 'artifacts', '04-plan.md'), `# 04-plan\n\n## Policy Checks\n- Keep the plan deterministic and minimal.\n- Map every step back to a diagnosed issue or architecture rule.\n\n## Risks\n- low\n\n## Step Breakdown\n- Step ID: step-01-extract-service\n  - Description: extract service module from legacy flow.\n  - Files: src/legacy.ts, src/services/legacy-service.ts\n  - Risk: 2\n  - Validation: npm test\n\n## Success Criteria\n- The plan enumerates executable steps.\n- Verification is defined before refactoring starts.\n\n## Verification\n- npm test\n`, 'utf8');
+  await fs.writeFile(path.join(repoRoot, '.prodify', 'artifacts', '05-refactor.md'), `# 05-refactor\n\n## Behavior Guardrails\n- keep the change scoped to one plan unit.\n\n## Changed Files\n- src/legacy.ts\n- src/services/legacy-service.ts\n\n## Policy Checks\n- Execute exactly one selected step.\n- Keep the diff minimal and behavior-preserving unless the plan says otherwise.\n\n## Selected Step\n- Step ID: step-01-extract-service\n- Description: extract service module from legacy flow.\n\n## Success Criteria\n- The selected plan step is implemented fully.\n- Unrelated files remain untouched.\n- The refactor introduces measurable structural improvement.\n`, 'utf8');
+
+  await fs.mkdir(path.join(repoRoot, 'src', 'services'), { recursive: true });
+  await fs.writeFile(path.join(repoRoot, 'src', 'legacy.ts'), `import { loadLegacyService } from './services/legacy-service.js';\n\nexport function legacyFlow() {\n  return loadLegacyService();\n}\n`, 'utf8');
+  await fs.writeFile(path.join(repoRoot, 'src', 'services', 'legacy-service.ts'), `export function loadLegacyService() {\n  const record = loadLegacy();\n  const normalized = normalizeLegacy(record);\n  return buildLegacyPayload(normalized);\n}\n`, 'utf8');
+
+  const diffResult = await diffAgainstRefactorBaseline(repoRoot);
+  const result = await validateStageOutputs(repoRoot, {
+    contract: await loadCompiledContract(repoRoot, 'refactor'),
+    runtimeState: refactorState,
+    touchedPaths: ['src/legacy.ts', 'src/services/legacy-service.ts', '.prodify/artifacts/05-refactor.md'],
+    diffResult
+  });
+
+  assert.equal(result.passed, true);
+  assert.equal(result.diff_result?.filesAdded, 1);
+  assert.match(result.diff_result?.structuralChanges.structural_change_flags.join(',') ?? '', /module-boundary-created/);
+});
+
+test('validate stage fails when impact score delta is below the configured threshold', async () => {
+  const repoRoot = await createTempRepo();
+  await execCli(repoRoot, ['init']);
+
+  const state = await readRuntimeState(repoRoot, {
+    presetMetadata: {
+      name: 'default',
+      version: '4.0.0',
+      schemaVersion: '4'
+    }
+  });
+
+  const bootstrapped = bootstrapFlowState(state, {
+    agent: 'codex',
+    mode: 'interactive'
+  });
+  await writeRuntimeState(repoRoot, bootstrapped);
+
+  const validateState = startFlowExecution(bootstrapped);
+  validateState.runtime.current_state = 'validate_pending';
+  validateState.runtime.current_stage = 'validate';
+  validateState.runtime.current_task_id = '06-validate';
+  await fs.writeFile(path.join(repoRoot, '.prodify', 'artifacts', '06-validate.md'), `# 06-validate\n\n## Policy Checks\n- Validation must follow every refactor step.\n- Critical regressions block forward progress.\n\n## Regressions\n- none observed\n\n## Success Criteria\n- Validation records whether regressions were found.\n- The result is strong enough to gate the next runtime transition.\n- The measured impact score exceeds the minimum threshold.\n\n## Validation Results\n- baseline and current score compared\n`, 'utf8');
+
+  const result = await validateStageOutputs(repoRoot, {
+    contract: await loadCompiledContract(repoRoot, 'validate'),
+    runtimeState: validateState,
+    touchedPaths: ['.prodify/artifacts/06-validate.md']
+  });
+
+  assert.equal(result.passed, false);
+  assert.match(result.violated_rules.map((issue) => issue.rule).join(','), /impact-score\/minimum-threshold/);
+});