@urielsh/prodify 0.1.1 → 0.1.3

package/dist/core/plan-units.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import { resolveCanonicalPath } from './paths.js';
+function extractSection(markdown, heading) {
+    const normalized = markdown.replace(/\r\n/g, '\n');
+    const match = new RegExp(`^##\\s+${heading}\\s*$([\\s\\S]*?)(?=^##\\s+|\\Z)`, 'm').exec(normalized);
+    return match?.[1]?.trim() ?? '';
+}
+function normalizePlanUnits(section) {
+    const lines = section.split('\n');
+    const units = [];
+    let currentId = null;
+    let currentDescription = '';
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        const idMatch = /^-\s+Step ID:\s+(.+)$/.exec(line);
+        if (idMatch) {
+            if (currentId) {
+                units.push({
+                    id: currentId,
+                    description: currentDescription
+                });
+            }
+            currentId = idMatch[1].trim();
+            currentDescription = '';
+            continue;
+        }
+        if (!currentId) {
+            continue;
+        }
+        const descriptionMatch = /^-\s+Description:\s+(.+)$/.exec(line);
+        if (descriptionMatch) {
+            currentDescription = descriptionMatch[1].trim();
+        }
+    }
+    if (currentId) {
+        units.push({
+            id: currentId,
+            description: currentDescription
+        });
+    }
+    return units;
+}
+export async function readPlanUnits(repoRoot) {
+    const planPath = resolveCanonicalPath(repoRoot, '.prodify/artifacts/04-plan.md');
+    const markdown = await fs.readFile(planPath, 'utf8');
+    return normalizePlanUnits(extractSection(markdown, 'Step Breakdown'));
+}
+export async function readSelectedRefactorStep(repoRoot) {
+    const refactorPath = resolveCanonicalPath(repoRoot, '.prodify/artifacts/05-refactor.md');
+    const markdown = await fs.readFile(refactorPath, 'utf8');
+    const section = extractSection(markdown, 'Selected Step');
+    if (!section) {
+        return null;
+    }
+    const id = /-\s+Step ID:\s+(.+)/.exec(section)?.[1]?.trim() ?? null;
+    const description = /-\s+Description:\s+(.+)/.exec(section)?.[1]?.trim() ?? '';
+    if (!id) {
+        return null;
+    }
+    return {
+        id,
+        description
+    };
+}

package/dist/core/repo-root.js

@@ -39,15 +39,24 @@ export async function resolveRepoRoot(options = {}) {
         }
         return explicitRepo;
     }
-    const prodifyRoot = await searchUpwards(cwd, async (candidate) => directoryHas(candidate, '.prodify'));
-    if (prodifyRoot) {
-        return prodifyRoot;
-    }
-    if (allowBootstrap) {
-        const gitRoot = await searchUpwards(cwd, async (candidate) => directoryHas(candidate, '.git'));
-        if (gitRoot) {
-            return gitRoot;
+    let current = cwd;
+    while (true) {
+        const hasProdify = await directoryHas(current, '.prodify');
+        if (hasProdify) {
+            return current;
+        }
+        const hasGit = await directoryHas(current, '.git');
+        if (hasGit) {
+            if (allowBootstrap) {
+                return current;
+            }
+            break;
         }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
     }
     throw new ProdifyError('Could not resolve repository root from the current working directory.', {
         code: 'REPO_ROOT_NOT_FOUND'

package/dist/core/state.js

@@ -2,6 +2,8 @@ import fs from 'node:fs/promises';
 import { ProdifyError } from './errors.js';
 import { pathExists, writeFileEnsuringDir } from './fs.js';
 import { resolveCanonicalPath } from './paths.js';
+import { writeRefactorBaselineSnapshot } from './diff-validator.js';
+import { syncScoreArtifactsForRuntimeState } from '../scoring/model.js';
 export const RUNTIME_STATE_SCHEMA_VERSION = '2';
 export const RUNTIME_STATUS = {
     NOT_BOOTSTRAPPED: 'not_bootstrapped',
@@ -217,4 +219,8 @@ export async function readRuntimeState(repoRoot, { allowMissing = false, presetM
 export async function writeRuntimeState(repoRoot, state) {
     const statePath = resolveCanonicalPath(repoRoot, '.prodify/state.json');
     await writeFileEnsuringDir(statePath, serializeRuntimeState(state));
+    if (state.runtime.current_state === 'refactor_pending') {
+        await writeRefactorBaselineSnapshot(repoRoot);
+    }
+    await syncScoreArtifactsForRuntimeState(repoRoot, state);
 }

package/dist/core/status.js

@@ -11,6 +11,7 @@ import { readRuntimeState, RUNTIME_STATUS } from './state.js';
 import { inspectVersionStatus } from './version-checks.js';
 import { buildBootstrapPrompt, hasManualBootstrapGuidance } from './prompt-builder.js';
 import { getRuntimeProfile } from './targets.js';
+import { readScoreDelta } from '../scoring/model.js';
 function describeCanonicalHealth(missingPaths) {
     if (missingPaths.length === 0) {
         return 'healthy';
@@ -126,6 +127,14 @@ function describeStageValidation(report) {
         ? `last pass at ${runtime.last_validation.stage} (contract ${runtime.last_validation.contract_version})`
         : `failed at ${runtime.last_validation.stage}`;
 }
+function describeImpactScore(scoreDelta) {
+    if (!scoreDelta) {
+        return 'not available';
+    }
+    const threshold = scoreDelta.min_impact_score !== undefined ? `, threshold=${scoreDelta.min_impact_score}` : '';
+    const verdict = scoreDelta.passed === undefined ? '' : `, passed=${scoreDelta.passed}`;
+    return `${scoreDelta.baseline_score} -> ${scoreDelta.final_score} (delta ${scoreDelta.delta}${threshold}${verdict})`;
+}
 async function checkManualBootstrapGuidance(repoRoot) {
     const agentsPath = resolveCanonicalPath(repoRoot, '.prodify/AGENTS.md');
     if (!(await pathExists(agentsPath))) {
@@ -192,6 +201,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
             bootstrapProfile,
             bootstrapPrompt,
             stageSkillResolution: null,
+            scoreDelta: null,
             recommendedNextAction: 'prodify init',
             presetMetadata: preset.metadata
         };
@@ -207,6 +217,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
     let runtimeState = null;
     let runtimeStateError = null;
     let stageSkillResolution = null;
+    let scoreDelta = null;
     try {
         runtimeState = await readRuntimeState(repoRoot, {
             presetMetadata: preset.metadata
@@ -216,6 +227,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
         runtimeStateError = error instanceof Error ? error : new Error(String(error));
     }
     const manualBootstrapReady = await checkManualBootstrapGuidance(repoRoot);
+    scoreDelta = await readScoreDelta(repoRoot);
     const canonicalOk = missingPaths.length === 0;
     if (canonicalOk && contractInventory.ok) {
         const skillStage = runtimeState?.runtime.current_stage
@@ -252,6 +264,7 @@ export async function inspectRepositoryStatus(repoRoot, options = {}) {
         bootstrapProfile,
         bootstrapPrompt,
         stageSkillResolution,
+        scoreDelta,
         recommendedNextAction: deriveNextAction({
             initialized,
             canonicalOk,
@@ -280,6 +293,7 @@ export function renderStatusReport(report) {
         `Skills active: ${describeActiveSkills(report)}`,
         `Execution state: ${describeRuntime(report.runtimeState?.runtime ?? null)}`,
         `Stage validation: ${describeStageValidation(report)}`,
+        `Impact score: ${describeImpactScore(report.scoreDelta)}`,
         `Manual bootstrap: ${report.manualBootstrapReady ? 'ready' : 'repair .prodify/AGENTS.md guidance'}`,
         `Bootstrap profile: ${report.bootstrapProfile}`,
         `Bootstrap prompt: ${report.bootstrapPrompt}`,

package/dist/core/validation.js

@@ -1,6 +1,9 @@
 import fs from 'node:fs/promises';
 import { loadCompiledContract } from '../contracts/compiler.js';
+import { diffAgainstRefactorBaseline } from './diff-validator.js';
 import { normalizeRepoRelativePath, resolveRepoPath } from './paths.js';
+import { readPlanUnits, readSelectedRefactorStep } from './plan-units.js';
+import { calculateCurrentImpactDelta } from '../scoring/model.js';
 function pathIsWithin(pathToCheck, root) {
     const normalizedPath = normalizeRepoRelativePath(pathToCheck);
     const normalizedRoot = normalizeRepoRelativePath(root);
@@ -35,6 +38,12 @@ function containsAllStatements(sectionContent, statements) {
 function buildRule(rule, message, path) {
     return { rule, message, path };
 }
+function hasRequiredStructuralChanges(diffResult, requiredChanges) {
+    if (requiredChanges.length === 0) {
+        return true;
+    }
+    return requiredChanges.every((requiredChange) => diffResult.structuralChanges.structural_change_flags.includes(requiredChange));
+}
 async function validateArtifact(repoRoot, contract, artifact) {
     const artifactPath = resolveRepoPath(repoRoot, artifact.path);
     const issues = [];
@@ -43,9 +52,6 @@ async function validateArtifact(repoRoot, contract, artifact) {
     try {
         const content = await fs.readFile(artifactPath, 'utf8');
         diagnostics.push(`validated artifact ${artifact.path}`);
-        if (!contract.allowed_write_roots.some((root) => pathIsWithin(artifact.path, root))) {
-            issues.push(buildRule('artifact/outside-allowed-roots', `Required artifact ${artifact.path} is outside allowed write roots.`, artifact.path));
-        }
         if (artifact.format === 'markdown') {
             const sections = collectMarkdownSections(content);
             for (const section of artifact.required_sections) {
@@ -81,11 +87,15 @@ async function validateArtifact(repoRoot, contract, artifact) {
         diagnostics
     };
 }
-export async function validateStageOutputs(repoRoot, { contract, runtimeState, touchedPaths = [] }) {
+export async function validateStageOutputs(repoRoot, { contract, runtimeState, touchedPaths = [], diffResult = null }) {
     const violatedRules = [];
     const missingArtifacts = [];
     const diagnostics = [];
     const warnings = [];
+    const effectiveDiffResult = diffResult ?? await diffAgainstRefactorBaseline(repoRoot);
+    const impactDelta = contract.min_impact_score > 0
+        ? await calculateCurrentImpactDelta(repoRoot)
+        : null;
     if (runtimeState.runtime.current_stage !== contract.stage) {
         violatedRules.push(buildRule('runtime/stage-mismatch', `Runtime stage ${runtimeState.runtime.current_stage ?? 'none'} does not match contract stage ${contract.stage}.`));
     }
@@ -106,6 +116,70 @@ export async function validateStageOutputs(repoRoot, { contract, runtimeState, t
     if (touchedPaths.length === 0) {
         warnings.push('No touched paths were provided; forbidden-write checks are limited to required artifacts.');
     }
+    if (contract.enforce_plan_units) {
+        try {
+            const [planUnits, selectedStep] = await Promise.all([
+                readPlanUnits(repoRoot),
+                readSelectedRefactorStep(repoRoot)
+            ]);
+            if (!selectedStep) {
+                violatedRules.push(buildRule('plan/selected-step-missing', 'Refactor artifact does not declare the selected plan unit.'));
+            }
+            else if (!planUnits.some((unit) => unit.id === selectedStep.id)) {
+                violatedRules.push(buildRule('plan/selected-step-invalid', `Selected refactor step ${selectedStep.id} does not exist in 04-plan.md.`));
+            }
+            else {
+                diagnostics.push(`validated selected plan unit ${selectedStep.id}`);
+            }
+        }
+        catch {
+            violatedRules.push(buildRule('plan/unreadable', 'Plan-unit validation could not read 04-plan.md or 05-refactor.md.'));
+        }
+    }
+    if (effectiveDiffResult && (contract.diff_validation_rules.minimum_files_modified > 0
+        || contract.diff_validation_rules.minimum_lines_changed > 0
+        || contract.diff_validation_rules.must_create_files
+        || contract.diff_validation_rules.required_structural_changes.length > 0)) {
+        const changedFiles = effectiveDiffResult.filesModified + effectiveDiffResult.filesAdded + effectiveDiffResult.filesDeleted;
+        const changedLines = effectiveDiffResult.linesAdded + effectiveDiffResult.linesRemoved;
+        const formattingOnly = effectiveDiffResult.filesModified > 0
+            && effectiveDiffResult.filesModified === effectiveDiffResult.formattingOnlyPaths.length
+            && effectiveDiffResult.filesAdded === 0
+            && effectiveDiffResult.filesDeleted === 0;
+        if (changedFiles < contract.diff_validation_rules.minimum_files_modified) {
+            violatedRules.push(buildRule('diff/minimum-files-modified', `Refactor changed ${changedFiles} files but requires at least ${contract.diff_validation_rules.minimum_files_modified}.`));
+        }
+        if (changedLines < contract.diff_validation_rules.minimum_lines_changed) {
+            violatedRules.push(buildRule('diff/minimum-lines-changed', `Refactor changed ${changedLines} lines but requires at least ${contract.diff_validation_rules.minimum_lines_changed}.`));
+        }
+        if (contract.diff_validation_rules.must_create_files && effectiveDiffResult.filesAdded === 0) {
+            violatedRules.push(buildRule('diff/must-create-files', 'Refactor must create at least one new file.'));
+        }
+        if (formattingOnly) {
+            violatedRules.push(buildRule('diff/formatting-only', 'Refactor changes are formatting-only and do not count as meaningful code change.'));
+        }
+        if (!hasRequiredStructuralChanges(effectiveDiffResult, contract.diff_validation_rules.required_structural_changes)) {
+            violatedRules.push(buildRule('diff/required-structural-changes', `Refactor is missing required structural changes: ${contract.diff_validation_rules.required_structural_changes.join(', ')}.`));
+        }
+        diagnostics.push(`validated diff: files=${changedFiles}, lines=${changedLines}, structural=${effectiveDiffResult.structuralChanges.structural_change_flags.join(',') || 'none'}`);
+    }
+    else if (contract.diff_validation_rules.minimum_files_modified > 0
+        || contract.diff_validation_rules.minimum_lines_changed > 0
+        || contract.diff_validation_rules.must_create_files
+        || contract.diff_validation_rules.required_structural_changes.length > 0) {
+        violatedRules.push(buildRule('diff/baseline-missing', 'Diff validation rules are configured but no refactor baseline snapshot was available.'));
+    }
+    if (contract.min_impact_score > 0) {
+        if (!impactDelta) {
+            violatedRules.push(buildRule('impact-score/missing-baseline', 'Impact score threshold is configured but no baseline score is available.'));
+        }
+        else if (impactDelta.delta < contract.min_impact_score) {
+            violatedRules.push(buildRule('impact-score/minimum-threshold', `Impact score delta ${impactDelta.delta} is below the required threshold ${contract.min_impact_score}.`));
+        }
+        else {
+            diagnostics.push(`validated impact score delta ${impactDelta.delta}`);
+        }
+    }
     return {
         stage: contract.stage,
         contract_version: contract.contract_version,
@@ -113,10 +187,12 @@ export async function validateStageOutputs(repoRoot, { contract, runtimeState, t
         violated_rules: violatedRules,
         missing_artifacts: [...new Set(missingArtifacts)].sort((left, right) => left.localeCompare(right)),
         warnings,
-        diagnostics
+        diagnostics,
+        ...(effectiveDiffResult ? { diff_result: effectiveDiffResult } : {}),
+        ...(impactDelta ? { impact_score_delta: impactDelta.delta } : {})
     };
 }
-export async function validateStageOutputsForCurrentState(repoRoot, { runtimeState, touchedPaths = [] }) {
+export async function validateStageOutputsForCurrentState(repoRoot, { runtimeState, touchedPaths = [], diffResult = null }) {
     const stage = runtimeState.runtime.current_stage;
     if (!stage) {
         throw new Error('Cannot validate stage outputs when no stage is active.');
@@ -125,14 +201,16 @@ export async function validateStageOutputsForCurrentState(repoRoot, { runtimeSta
     return validateStageOutputs(repoRoot, {
         contract,
         runtimeState,
-        touchedPaths
+        touchedPaths,
+        diffResult
     });
 }
-export async function validateStageOutputsForStage(repoRoot, { stage, runtimeState, touchedPaths = [] }) {
+export async function validateStageOutputsForStage(repoRoot, { stage, runtimeState, touchedPaths = [], diffResult = null }) {
     const contract = await loadCompiledContract(repoRoot, stage);
     return validateStageOutputs(repoRoot, {
         contract,
         runtimeState,
-        touchedPaths
+        touchedPaths,
+        diffResult
     });
 }