@urielsh/prodify 0.1.0

package/dist/core/repo-context.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs/promises';
+import { listFilesRecursive, pathExists } from './fs.js';
+import { resolveRepoPath } from './paths.js';
+function sortedUnique(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+async function readPackageJson(repoRoot) {
+    const packageJsonPath = resolveRepoPath(repoRoot, 'package.json');
+    if (!(await pathExists(packageJsonPath))) {
+        return null;
+    }
+    try {
+        return JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function dependencyEntries(packageJson) {
+    if (!packageJson) {
+        return [];
+    }
+    const sections = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+    const names = [];
+    for (const section of sections) {
+        const record = packageJson[section];
+        if (typeof record !== 'object' || record === null || Array.isArray(record)) {
+            continue;
+        }
+        names.push(...Object.keys(record));
+    }
+    return sortedUnique(names);
+}
+export async function detectRepoContext(repoRoot) {
+    const packageJson = await readPackageJson(repoRoot);
+    const dependencies = dependencyEntries(packageJson);
+    const files = await listFilesRecursive(repoRoot);
+    const relativePaths = files.map((entry) => entry.relativePath.replaceAll('\\', '/'));
+    const hasTsConfig = relativePaths.includes('tsconfig.json');
+    const hasTypeScriptSources = relativePaths.some((relativePath) => relativePath.endsWith('.ts') || relativePath.endsWith('.tsx'));
+    const hasJavaScriptSources = relativePaths.some((relativePath) => relativePath.endsWith('.js') || relativePath.endsWith('.jsx'));
+    const hasTests = relativePaths.some((relativePath) => relativePath.startsWith('tests/') || relativePath.includes('.test.'));
+    const hasCliEntrypoint = relativePaths.includes('src/cli.ts')
+        || relativePaths.includes('src/cli.js')
+        || relativePaths.includes('bin/prodify');
+    const hasCoreDir = relativePaths.some((relativePath) => relativePath.startsWith('src/core/'));
+    const hasCommandsDir = relativePaths.some((relativePath) => relativePath.startsWith('src/commands/'));
+    const languages = sortedUnique([
+        ...(hasTypeScriptSources || hasTsConfig ? ['typescript'] : []),
+        ...(hasJavaScriptSources || packageJson ? ['javascript'] : [])
+    ]);
+    const frameworks = sortedUnique([
+        ...(dependencies.includes('react') || dependencies.includes('react-dom') ? ['react'] : [])
+    ]);
+    const projectTypes = sortedUnique([
+        ...(packageJson ? ['node-package'] : []),
+        ...(hasCliEntrypoint ? ['cli'] : []),
+        ...(frameworks.includes('react') ? ['frontend-app'] : []),
+        ...(!frameworks.includes('react') && hasCoreDir ? ['backend-service'] : [])
+    ]);
+    const architecturePatterns = sortedUnique([
+        ...(hasCoreDir && hasCommandsDir ? ['layered-cli'] : []),
+        ...(relativePaths.some((relativePath) => relativePath.startsWith('src/contracts/')) ? ['contract-driven-runtime'] : [])
+    ]);
+    const riskSignals = sortedUnique([
+        ...(dependencies.length > 0 ? ['external-dependencies'] : []),
+        ...(hasCliEntrypoint ? ['cli-surface'] : []),
+        ...(!hasTests ? ['missing-tests'] : [])
+    ]);
+    return {
+        languages,
+        frameworks,
+        project_types: projectTypes,
+        architecture_patterns: architecturePatterns,
+        risk_signals: riskSignals
+    };
+}

package/dist/core/repo-root.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ProdifyError } from './errors.js';
+async function isDirectory(targetPath) {
+    try {
+        return (await fs.stat(targetPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryHas(directory, childName) {
+    return isDirectory(path.join(directory, childName));
+}
+async function searchUpwards(startDir, predicate) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (await predicate(current)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+export async function resolveRepoRoot(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const explicitRepo = options.repoRoot ? path.resolve(options.repoRoot) : null;
+    const allowBootstrap = options.allowBootstrap ?? false;
+    if (explicitRepo) {
+        const hasProdify = await directoryHas(explicitRepo, '.prodify');
+        const hasGit = await directoryHas(explicitRepo, '.git');
+        if (!hasProdify && !(allowBootstrap && hasGit)) {
+            throw new ProdifyError(`Could not verify repository root at ${explicitRepo}.`, {
+                code: 'REPO_ROOT_NOT_FOUND'
+            });
+        }
+        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;
+        }
+    }
+    throw new ProdifyError('Could not resolve repository root from the current working directory.', {
+        code: 'REPO_ROOT_NOT_FOUND'
+    });
+}

package/dist/core/skill-resolution.js

@@ -0,0 +1,123 @@
+import { loadCompiledContract } from '../contracts/compiler.js';
+import { ProdifyError } from './errors.js';
+import { detectRepoContext } from './repo-context.js';
+import { loadSkillRegistry } from '../skills/loader.js';
+function factValues(context, fact) {
+    switch (fact) {
+        case 'language':
+            return context.languages;
+        case 'framework':
+            return context.frameworks;
+        case 'project_type':
+            return context.project_types;
+        case 'architecture_pattern':
+            return context.architecture_patterns;
+        case 'risk_signal':
+            return context.risk_signals;
+        default:
+            return [];
+    }
+}
+function formatCondition(condition) {
+    return condition.all.map((predicate) => `${predicate.fact}=${predicate.includes}`).join(' and ');
+}
+function formatSkillActivationConditions(skill) {
+    return skill.activation_conditions.map((condition) => formatCondition(condition)).join(' or ');
+}
+function matchesCondition(context, condition) {
+    return condition.all.every((predicate) => factValues(context, predicate.fact).includes(predicate.includes));
+}
+function matchesSkillActivationConditions(context, skill) {
+    if (skill.activation_conditions.length === 0) {
+        return true;
+    }
+    return skill.activation_conditions.some((condition) => matchesCondition(context, condition));
+}
+function assertStageCompatible(skill, stage) {
+    if (!skill.stage_compatibility.includes(stage)) {
+        throw new ProdifyError(`Skill "${skill.id}" is not compatible with stage "${stage}".`, {
+            code: 'SKILL_STAGE_INCOMPATIBLE'
+        });
+    }
+}
+function resolveSkill(registry, skillId, stage) {
+    const skill = registry.get(skillId);
+    if (!skill) {
+        throw new ProdifyError(`Stage skill routing references unknown skill "${skillId}".`, {
+            code: 'SKILL_NOT_FOUND'
+        });
+    }
+    assertStageCompatible(skill, stage);
+    return skill;
+}
+function defaultRecord(skill, active) {
+    return {
+        id: skill.id,
+        name: skill.name,
+        category: skill.category,
+        source: 'default',
+        active,
+        reason: active ? 'default stage skill' : `inactive: ${formatSkillActivationConditions(skill)}`
+    };
+}
+function conditionalRecord(skill, conditionLabel, active) {
+    return {
+        id: skill.id,
+        name: skill.name,
+        category: skill.category,
+        source: 'conditional',
+        active,
+        reason: active ? conditionLabel : `inactive: ${conditionLabel}`
+    };
+}
+function validateRouting(routing, registry, stage) {
+    for (const skillId of routing.allowed_skills) {
+        resolveSkill(registry, skillId, stage);
+    }
+}
+export async function resolveStageSkills(repoRoot, stage) {
+    const [contract, registry, context] = await Promise.all([
+        loadCompiledContract(repoRoot, stage),
+        loadSkillRegistry(repoRoot),
+        detectRepoContext(repoRoot)
+    ]);
+    const routing = contract.skill_routing;
+    validateRouting(routing, registry, stage);
+    const consideredSkills = [];
+    const activeSkillIds = new Set();
+    for (const skillId of routing.default_skills) {
+        const skill = resolveSkill(registry, skillId, stage);
+        const active = matchesSkillActivationConditions(context, skill);
+        consideredSkills.push(defaultRecord(skill, active));
+        if (active) {
+            activeSkillIds.add(skill.id);
+        }
+    }
+    for (const rule of routing.conditional_skills) {
+        const skill = resolveSkill(registry, rule.skill, stage);
+        const conditionLabel = rule.reason || formatCondition(rule.when);
+        const active = matchesCondition(context, rule.when) && matchesSkillActivationConditions(context, skill);
+        const existing = consideredSkills.find((entry) => entry.id === skill.id);
+        if (existing) {
+            if (active) {
+                existing.active = true;
+                existing.reason = `${existing.reason}; ${conditionLabel}`;
+                activeSkillIds.add(skill.id);
+            }
+            else if (!existing.active && skill.activation_conditions.length > 0) {
+                existing.reason = `inactive: ${formatSkillActivationConditions(skill)}`;
+            }
+            continue;
+        }
+        consideredSkills.push(conditionalRecord(skill, conditionLabel, active));
+        if (active) {
+            activeSkillIds.add(skill.id);
+        }
+    }
+    return {
+        stage,
+        context,
+        considered_skills: consideredSkills.sort((left, right) => left.id.localeCompare(right.id)),
+        active_skill_ids: [...activeSkillIds].sort((left, right) => left.localeCompare(right))
+    };
+}

package/dist/core/state.js

@@ -0,0 +1,220 @@
+import fs from 'node:fs/promises';
+import { ProdifyError } from './errors.js';
+import { pathExists, writeFileEnsuringDir } from './fs.js';
+import { resolveCanonicalPath } from './paths.js';
+export const RUNTIME_STATE_SCHEMA_VERSION = '2';
+export const RUNTIME_STATUS = {
+    NOT_BOOTSTRAPPED: 'not_bootstrapped',
+    READY: 'ready',
+    RUNNING: 'running',
+    AWAITING_VALIDATION: 'awaiting_validation',
+    BLOCKED: 'blocked',
+    FAILED: 'failed',
+    COMPLETE: 'complete'
+};
+function isExecutionMode(value) {
+    return value === 'interactive' || value === 'auto';
+}
+function isFlowStage(value) {
+    return value === 'understand'
+        || value === 'diagnose'
+        || value === 'architecture'
+        || value === 'plan'
+        || value === 'refactor'
+        || value === 'validate';
+}
+function isRuntimeStatus(value) {
+    return value === 'not_bootstrapped'
+        || value === 'ready'
+        || value === 'running'
+        || value === 'awaiting_validation'
+        || value === 'blocked'
+        || value === 'failed'
+        || value === 'complete';
+}
+function isValidationResult(value) {
+    return value === 'unknown' || value === 'pass' || value === 'fail' || value === 'inconclusive';
+}
+function isRuntimeContractState(value) {
+    return typeof value === 'string' && [
+        'not_bootstrapped',
+        'bootstrapped',
+        'understand_pending',
+        'understand_complete',
+        'diagnose_pending',
+        'diagnose_complete',
+        'architecture_pending',
+        'architecture_complete',
+        'plan_pending',
+        'plan_complete',
+        'refactor_pending',
+        'refactor_complete',
+        'validate_pending',
+        'validate_complete',
+        'blocked',
+        'failed',
+        'completed'
+    ].includes(value);
+}
+function normalizeStageList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isFlowStage);
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+function normalizeBootstrapMetadata(value) {
+    const record = asRecord(value);
+    return {
+        bootstrapped: Boolean(record.bootstrapped)
+    };
+}
+function normalizeFailureMetadata(value) {
+    if (!value) {
+        return null;
+    }
+    const record = asRecord(value);
+    return {
+        stage: isFlowStage(record.stage) ? record.stage : null,
+        contract_version: typeof record.contract_version === 'string' ? record.contract_version : null,
+        reason: typeof record.reason === 'string' ? record.reason : 'unknown failure'
+    };
+}
+function normalizeValidation(value) {
+    if (!value) {
+        return null;
+    }
+    const record = asRecord(value);
+    return {
+        stage: isFlowStage(record.stage) ? record.stage : 'understand',
+        contract_version: typeof record.contract_version === 'string' ? record.contract_version : 'unknown',
+        passed: Boolean(record.passed),
+        violated_rules: Array.isArray(record.violated_rules)
+            ? record.violated_rules
+                .map((entry) => asRecord(entry))
+                .map((entry) => ({
+                rule: typeof entry.rule === 'string' ? entry.rule : 'unknown',
+                message: typeof entry.message === 'string' ? entry.message : 'validation issue',
+                path: typeof entry.path === 'string' ? entry.path : undefined
+            }))
+            : [],
+        missing_artifacts: Array.isArray(record.missing_artifacts)
+            ? record.missing_artifacts.filter((entry) => typeof entry === 'string')
+            : [],
+        warnings: Array.isArray(record.warnings)
+            ? record.warnings.filter((entry) => typeof entry === 'string')
+            : [],
+        diagnostics: Array.isArray(record.diagnostics)
+            ? record.diagnostics.filter((entry) => typeof entry === 'string')
+            : []
+    };
+}
+function normalizeValidatedContractVersions(value) {
+    const record = asRecord(value);
+    const normalized = {};
+    for (const [key, rawValue] of Object.entries(record)) {
+        if (isFlowStage(key) && typeof rawValue === 'string') {
+            normalized[key] = rawValue;
+        }
+    }
+    return normalized;
+}
+export function createInitialRuntimeState({ presetMetadata }) {
+    return {
+        schema_version: RUNTIME_STATE_SCHEMA_VERSION,
+        preset_name: presetMetadata.name,
+        preset_version: presetMetadata.version,
+        runtime: {
+            status: RUNTIME_STATUS.NOT_BOOTSTRAPPED,
+            current_state: 'not_bootstrapped',
+            mode: null,
+            current_stage: null,
+            current_task_id: null,
+            pending_stage: null,
+            completed_stages: [],
+            awaiting_user_validation: false,
+            last_validation_result: 'unknown',
+            last_validation: null,
+            last_validated_contract_versions: {},
+            resumable: false,
+            blocked_reason: null,
+            failure_metadata: null,
+            bootstrap: {
+                bootstrapped: false
+            },
+            next_action: '$prodify-init',
+            timestamps: {
+                bootstrapped_at: null,
+                last_transition_at: null,
+                completed_at: null
+            }
+        }
+    };
+}
+function normalizeRuntimeBlock(runtime) {
+    const record = asRecord(runtime);
+    const timestamps = asRecord(record.timestamps);
+    return {
+        status: isRuntimeStatus(record.status) ? record.status : RUNTIME_STATUS.NOT_BOOTSTRAPPED,
+        current_state: isRuntimeContractState(record.current_state) ? record.current_state : 'not_bootstrapped',
+        mode: isExecutionMode(record.mode) ? record.mode : null,
+        current_stage: isFlowStage(record.current_stage) ? record.current_stage : null,
+        current_task_id: typeof record.current_task_id === 'string' ? record.current_task_id : null,
+        pending_stage: isFlowStage(record.pending_stage) ? record.pending_stage : null,
+        completed_stages: normalizeStageList(record.completed_stages),
+        awaiting_user_validation: Boolean(record.awaiting_user_validation),
+        last_validation_result: isValidationResult(record.last_validation_result) ? record.last_validation_result : 'unknown',
+        last_validation: normalizeValidation(record.last_validation),
+        last_validated_contract_versions: normalizeValidatedContractVersions(record.last_validated_contract_versions),
+        resumable: Boolean(record.resumable),
+        blocked_reason: typeof record.blocked_reason === 'string' ? record.blocked_reason : null,
+        failure_metadata: normalizeFailureMetadata(record.failure_metadata),
+        bootstrap: normalizeBootstrapMetadata(record.bootstrap),
+        next_action: typeof record.next_action === 'string' ? record.next_action : '$prodify-init',
+        timestamps: {
+            bootstrapped_at: typeof timestamps.bootstrapped_at === 'string' ? timestamps.bootstrapped_at : null,
+            last_transition_at: typeof timestamps.last_transition_at === 'string' ? timestamps.last_transition_at : null,
+            completed_at: typeof timestamps.completed_at === 'string' ? timestamps.completed_at : null
+        }
+    };
+}
+export function normalizeRuntimeState(raw, { presetMetadata }) {
+    const record = asRecord(raw);
+    const base = createInitialRuntimeState({ presetMetadata });
+    return {
+        ...base,
+        schema_version: base.schema_version,
+        preset_name: presetMetadata.name,
+        preset_version: presetMetadata.version,
+        runtime: normalizeRuntimeBlock(record.runtime)
+    };
+}
+export function serializeRuntimeState(state) {
+    return `${JSON.stringify(state, null, 2)}\n`;
+}
+export async function readRuntimeState(repoRoot, { allowMissing = false, presetMetadata }) {
+    const statePath = resolveCanonicalPath(repoRoot, '.prodify/state.json');
+    if (!(await pathExists(statePath))) {
+        if (allowMissing) {
+            return null;
+        }
+        throw new ProdifyError('Runtime state is missing: .prodify/state.json', {
+            code: 'RUNTIME_STATE_MISSING'
+        });
+    }
+    try {
+        const raw = JSON.parse(await fs.readFile(statePath, 'utf8'));
+        return normalizeRuntimeState(raw, { presetMetadata });
+    }
+    catch {
+        throw new ProdifyError('Runtime state is malformed: .prodify/state.json', {
+            code: 'RUNTIME_STATE_MALFORMED'
+        });
+    }
+}
+export async function writeRuntimeState(repoRoot, state) {
+    const statePath = resolveCanonicalPath(repoRoot, '.prodify/state.json');
+    await writeFileEnsuringDir(statePath, serializeRuntimeState(state));
+}