@urielsh/prodify 0.1.0

package/dist/generators/copilot.js

@@ -0,0 +1,29 @@
+import { buildManagedMarkdownOutput, readCanonicalMarkdown, stripLeadingTitle } from './shared.js';
+import { LEGACY_TARGET_PATH_DEFINITIONS } from '../core/paths.js';
+export async function generateCopilotContent(repoRoot) {
+    const target = LEGACY_TARGET_PATH_DEFINITIONS.copilot;
+    const agentsMarkdown = await readCanonicalMarkdown(repoRoot, '.prodify/AGENTS.md');
+    const projectMarkdown = await readCanonicalMarkdown(repoRoot, '.prodify/project.md');
+    const runtimeMarkdown = await readCanonicalMarkdown(repoRoot, '.prodify/runtime-commands.md');
+    const body = [
+        '# Copilot Instructions',
+        '',
+        '## Project Context',
+        '',
+        stripLeadingTitle(projectMarkdown),
+        '',
+        '## Operating Guidance',
+        '',
+        stripLeadingTitle(agentsMarkdown),
+        '',
+        '## Runtime Commands',
+        '',
+        stripLeadingTitle(runtimeMarkdown)
+    ].join('\n').trimEnd() + '\n';
+    return buildManagedMarkdownOutput({
+        agent: target.agent,
+        canonicalSources: target.canonicalSources,
+        regenerateCommand: 'prodify update',
+        body
+    });
+}

package/dist/generators/header.js

@@ -0,0 +1,13 @@
+import { renderCanonicalSourceList } from '../core/managed-files.js';
+export function renderManagedFileHeader({ agent, canonicalSources, regenerateCommand, bodyFingerprint }) {
+    return [
+        '<!--',
+        'Generated by Prodify.',
+        `Target agent: ${agent}`,
+        `Canonical source: ${renderCanonicalSourceList(canonicalSources)}`,
+        `Regenerate with: ${regenerateCommand}`,
+        `Body fingerprint: ${bodyFingerprint}`,
+        'Manual edits may be overwritten.',
+        '-->'
+    ].join('\n');
+}

package/dist/generators/opencode.js

@@ -0,0 +1,14 @@
+import { buildManagedMarkdownOutput, readCanonicalMarkdown } from './shared.js';
+import { LEGACY_TARGET_PATH_DEFINITIONS } from '../core/paths.js';
+export async function generateOpenCodeContent(repoRoot) {
+    const target = LEGACY_TARGET_PATH_DEFINITIONS.opencode;
+    const guidance = await readCanonicalMarkdown(repoRoot, target.canonicalSources[0]);
+    const runtime = await readCanonicalMarkdown(repoRoot, '.prodify/runtime-commands.md');
+    const body = `${guidance.trimEnd()}\n\n${runtime.trim()}\n`;
+    return buildManagedMarkdownOutput({
+        agent: target.agent,
+        canonicalSources: target.canonicalSources,
+        regenerateCommand: 'prodify update',
+        body
+    });
+}

package/dist/generators/shared.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs/promises';
+import { ProdifyError } from '../core/errors.js';
+import { resolveCanonicalPath } from '../core/paths.js';
+import { computeBodyFingerprint } from '../core/managed-files.js';
+import { renderManagedFileHeader } from './header.js';
+export async function readCanonicalMarkdown(repoRoot, relativePath) {
+    const absolutePath = resolveCanonicalPath(repoRoot, relativePath);
+    try {
+        return await fs.readFile(absolutePath, 'utf8');
+    }
+    catch {
+        throw new ProdifyError(`Canonical source is missing: ${relativePath}`, {
+            code: 'CANONICAL_SOURCE_MISSING'
+        });
+    }
+}
+export function stripLeadingTitle(markdown) {
+    const lines = markdown.split('\n');
+    if (lines[0]?.startsWith('# ')) {
+        let index = 1;
+        while (index < lines.length && lines[index].trim() === '') {
+            index += 1;
+        }
+        return lines.slice(index).join('\n').trim();
+    }
+    return markdown.trim();
+}
+export function buildManagedMarkdownOutput({ agent, canonicalSources, regenerateCommand, body }) {
+    const bodyFingerprint = computeBodyFingerprint(body);
+    const header = renderManagedFileHeader({
+        agent,
+        canonicalSources,
+        regenerateCommand,
+        bodyFingerprint
+    });
+    return `${header}\n\n${body}`;
+}

package/dist/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { runCli } from './cli.js';
+const context = {
+    cwd: process.cwd(),
+    stdout: process.stdout,
+    stderr: process.stderr
+};
+const exitCode = await runCli(process.argv.slice(2), context);
+process.exitCode = exitCode;

package/dist/legacy/targets.js

@@ -0,0 +1,55 @@
+import { ProdifyError } from '../core/errors.js';
+import { LEGACY_TARGET_PATH_DEFINITIONS, isRuntimeProfileName } from '../core/paths.js';
+import { generateCodexContent } from '../generators/codex.js';
+import { generateClaudeContent } from '../generators/claude.js';
+import { generateCopilotContent } from '../generators/copilot.js';
+import { generateOpenCodeContent } from '../generators/opencode.js';
+export const LEGACY_TARGET_REGISTRY = {
+    codex: {
+        ...LEGACY_TARGET_PATH_DEFINITIONS.codex,
+        enabled: true,
+        doctorEligible: false,
+        generator: generateCodexContent
+    },
+    claude: {
+        ...LEGACY_TARGET_PATH_DEFINITIONS.claude,
+        enabled: true,
+        doctorEligible: false,
+        generator: generateClaudeContent
+    },
+    copilot: {
+        ...LEGACY_TARGET_PATH_DEFINITIONS.copilot,
+        enabled: true,
+        doctorEligible: false,
+        generator: generateCopilotContent
+    },
+    opencode: {
+        ...LEGACY_TARGET_PATH_DEFINITIONS.opencode,
+        enabled: true,
+        doctorEligible: false,
+        generator: generateOpenCodeContent
+    }
+};
+export function listLegacyTargets() {
+    return Object.values(LEGACY_TARGET_REGISTRY);
+}
+export function getLegacyTarget(agent) {
+    if (!agent || !isRuntimeProfileName(agent)) {
+        return null;
+    }
+    return LEGACY_TARGET_REGISTRY[agent];
+}
+export function assertSupportedInstallTarget(agent) {
+    const metadata = getLegacyTarget(agent);
+    if (!metadata) {
+        throw new ProdifyError(`Unknown target agent: ${agent}`, {
+            code: 'UNKNOWN_TARGET'
+        });
+    }
+    if (!metadata.enabled || !metadata.generator) {
+        throw new ProdifyError(`Legacy compatibility target ${agent} is not enabled.`, {
+            code: 'TARGET_NOT_ENABLED'
+        });
+    }
+    return metadata;
+}

package/dist/presets/default.js

@@ -0,0 +1,3 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const DEFAULT_PRESET_ASSET_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../assets/presets/default');

package/dist/presets/loader.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { listFilesRecursive } from '../core/fs.js';
+import { validatePresetEntries } from '../core/preset-validation.js';
+import { DEFAULT_PRESET_ASSET_DIR } from './default.js';
+import { serializeVersionMetadata } from './version.js';
+export async function loadDefaultPreset() {
+    const metadataPath = path.join(DEFAULT_PRESET_ASSET_DIR, 'preset.json');
+    const canonicalDir = path.join(DEFAULT_PRESET_ASSET_DIR, 'canonical');
+    const rawMetadata = JSON.parse(await fs.readFile(metadataPath, 'utf8'));
+    const metadata = {
+        name: rawMetadata.name,
+        version: rawMetadata.version,
+        schemaVersion: rawMetadata.schemaVersion
+    };
+    const rawFiles = await listFilesRecursive(canonicalDir);
+    const entries = [];
+    for (const file of rawFiles) {
+        entries.push({
+            relativePath: `.prodify/${file.relativePath}`,
+            content: await fs.readFile(file.fullPath, 'utf8')
+        });
+    }
+    entries.push({
+        relativePath: '.prodify/version.json',
+        content: serializeVersionMetadata(metadata)
+    });
+    entries.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    validatePresetEntries(entries);
+    return {
+        metadata,
+        entries
+    };
+}

package/dist/presets/version.js

@@ -0,0 +1,18 @@
+export function createVersionMetadata(presetMetadata) {
+    return {
+        schema_version: presetMetadata.schemaVersion,
+        preset_name: presetMetadata.name,
+        preset_version: presetMetadata.version
+    };
+}
+export function serializeVersionMetadata(presetMetadata) {
+    return `${JSON.stringify(createVersionMetadata(presetMetadata), null, 2)}\n`;
+}
+export function parseVersionMetadata(content) {
+    const parsed = JSON.parse(content);
+    return {
+        schemaVersion: parsed.schema_version,
+        presetName: parsed.preset_name,
+        presetVersion: parsed.preset_version
+    };
+}

package/dist/scoring/model.js

@@ -0,0 +1,262 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { inspectCompiledContracts } from '../contracts/freshness.js';
+import { ProdifyError } from '../core/errors.js';
+import { listFilesRecursive, pathExists, writeFileEnsuringDir } from '../core/fs.js';
+import { resolveRepoPath } from '../core/paths.js';
+const SCORE_SCHEMA_VERSION = '1';
+function roundScore(value) {
+    return Math.round(value * 100) / 100;
+}
+function createMetric(options) {
+    const ratio = Math.max(0, Math.min(1, options.ratio));
+    const points = roundScore(options.weight * ratio);
+    return {
+        id: options.id,
+        label: options.label,
+        tool: options.tool,
+        weight: options.weight,
+        max_points: options.weight,
+        points,
+        status: ratio === 1 ? 'pass' : ratio === 0 ? 'fail' : 'partial',
+        details: options.details
+    };
+}
+async function detectEcosystems(repoRoot) {
+    const ecosystems = [];
+    if (await pathExists(resolveRepoPath(repoRoot, 'package.json'))) {
+        ecosystems.push('typescript-javascript');
+    }
+    const repoFiles = await listFilesRecursive(repoRoot);
+    if (repoFiles.some((file) => file.relativePath.endsWith('.py'))) {
+        ecosystems.push('python');
+    }
+    if (repoFiles.some((file) => file.relativePath.endsWith('.cs') || file.relativePath.endsWith('.csproj') || file.relativePath.endsWith('.sln'))) {
+        ecosystems.push('csharp');
+    }
+    return ecosystems.sort((left, right) => left.localeCompare(right));
+}
+async function buildEcosystemMetrics(repoRoot, ecosystems) {
+    const metrics = [];
+    const toolOutputs = [];
+    if (ecosystems.includes('typescript-javascript')) {
+        const packageJsonPath = resolveRepoPath(repoRoot, 'package.json');
+        const tsconfigPath = resolveRepoPath(repoRoot, 'tsconfig.json');
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+        const scripts = packageJson.scripts ?? {};
+        const hasBuild = typeof scripts.build === 'string' && scripts.build.length > 0;
+        const hasTest = typeof scripts.test === 'string' && scripts.test.length > 0;
+        const hasTsconfig = await pathExists(tsconfigPath);
+        const score = [hasBuild, hasTest, hasTsconfig].filter(Boolean).length / 3;
+        metrics.push(createMetric({
+            id: 'typescript-javascript',
+            label: 'TypeScript/JavaScript local tooling',
+            tool: 'package-json',
+            weight: 15,
+            ratio: score,
+            details: `build=${hasBuild}, test=${hasTest}, tsconfig=${hasTsconfig}`
+        }));
+        toolOutputs.push({
+            adapter: 'typescript-javascript',
+            details: {
+                build_script: hasBuild,
+                test_script: hasTest,
+                tsconfig: hasTsconfig
+            }
+        });
+    }
+    if (ecosystems.includes('python')) {
+        const hasPyproject = await pathExists(resolveRepoPath(repoRoot, 'pyproject.toml'));
+        const hasRequirements = await pathExists(resolveRepoPath(repoRoot, 'requirements.txt'));
+        const ratio = [hasPyproject, hasRequirements].filter(Boolean).length / 2;
+        metrics.push(createMetric({
+            id: 'python',
+            label: 'Python local tooling',
+            tool: 'filesystem',
+            weight: 7.5,
+            ratio,
+            details: `pyproject=${hasPyproject}, requirements=${hasRequirements}`
+        }));
+        toolOutputs.push({
+            adapter: 'python',
+            details: {
+                pyproject: hasPyproject,
+                requirements: hasRequirements
+            }
+        });
+    }
+    if (ecosystems.includes('csharp')) {
+        const repoFiles = await listFilesRecursive(repoRoot);
+        const hasSolution = repoFiles.some((file) => file.relativePath.endsWith('.sln'));
+        const hasProject = repoFiles.some((file) => file.relativePath.endsWith('.csproj'));
+        const ratio = [hasSolution, hasProject].filter(Boolean).length / 2;
+        metrics.push(createMetric({
+            id: 'csharp',
+            label: 'C# local tooling',
+            tool: 'filesystem',
+            weight: 7.5,
+            ratio,
+            details: `solution=${hasSolution}, project=${hasProject}`
+        }));
+        toolOutputs.push({
+            adapter: 'csharp',
+            details: {
+                solution: hasSolution,
+                project: hasProject
+            }
+        });
+    }
+    return {
+        metrics,
+        toolOutputs
+    };
+}
+async function buildRepoHygieneMetric(repoRoot) {
+    const requiredSignals = ['README.md', 'LICENSE', 'tests', '.prodify/contracts-src'];
+    const available = await Promise.all(requiredSignals.map((relativePath) => pathExists(resolveRepoPath(repoRoot, relativePath))));
+    const ratio = available.filter(Boolean).length / requiredSignals.length;
+    return {
+        metric: createMetric({
+            id: 'repo-hygiene',
+            label: 'Repository hygiene signals',
+            tool: 'filesystem',
+            weight: 20,
+            ratio,
+            details: requiredSignals.map((entry, index) => `${entry}=${available[index]}`).join(', ')
+        }),
+        toolOutput: {
+            adapter: 'filesystem',
+            details: Object.fromEntries(requiredSignals.map((entry, index) => [entry, available[index]]))
+        }
+    };
+}
+function buildRuntimeMetric(runtimeState) {
+    const healthyState = runtimeState.runtime.current_state !== 'failed' && runtimeState.runtime.current_state !== 'blocked';
+    const ratio = healthyState ? 1 : 0;
+    return {
+        metric: createMetric({
+            id: 'runtime-state',
+            label: 'Contract-driven runtime state',
+            tool: 'state-json',
+            weight: 25,
+            ratio,
+            details: `current_state=${runtimeState.runtime.current_state}, status=${runtimeState.runtime.status}`
+        }),
+        toolOutput: {
+            adapter: 'state-json',
+            details: {
+                current_state: runtimeState.runtime.current_state,
+                status: runtimeState.runtime.status,
+                last_validation_result: runtimeState.runtime.last_validation_result
+            }
+        }
+    };
+}
+function buildValidationMetric(runtimeState) {
+    const passed = runtimeState.runtime.last_validation?.passed === true;
+    const finalReady = runtimeState.runtime.current_state === 'validate_complete' || runtimeState.runtime.current_state === 'completed';
+    const ratio = passed ? (finalReady ? 1 : 0.5) : 0;
+    return {
+        metric: createMetric({
+            id: 'validation-gate',
+            label: 'Validated contract completion',
+            tool: 'state-json',
+            weight: 10,
+            ratio,
+            details: `passed=${passed}, final_ready=${finalReady}`
+        }),
+        toolOutput: {
+            adapter: 'validation-gate',
+            details: {
+                passed,
+                final_ready: finalReady
+            }
+        }
+    };
+}
+export async function calculateLocalScore(repoRoot, { kind, runtimeState }) {
+    const contractInventory = await inspectCompiledContracts(repoRoot);
+    const ecosystems = await detectEcosystems(repoRoot);
+    const metrics = [];
+    const toolOutputs = [];
+    metrics.push(createMetric({
+        id: 'contracts',
+        label: 'Compiled contract health',
+        tool: 'contract-compiler',
+        weight: 30,
+        ratio: contractInventory.ok ? 1 : Math.max(0, 1 - ((contractInventory.missingCompiledStages.length + contractInventory.staleStages.length) / 6)),
+        details: `source=${contractInventory.sourceCount}, compiled=${contractInventory.compiledCount}, stale=${contractInventory.staleStages.length}, missing=${contractInventory.missingCompiledStages.length}`
+    }));
+    toolOutputs.push({
+        adapter: 'contract-compiler',
+        details: {
+            ok: contractInventory.ok,
+            sourceCount: contractInventory.sourceCount,
+            compiledCount: contractInventory.compiledCount,
+            staleStages: contractInventory.staleStages,
+            missingCompiledStages: contractInventory.missingCompiledStages,
+            missingSourceStages: contractInventory.missingSourceStages,
+            invalidStages: contractInventory.invalidStages
+        }
+    });
+    const runtimeMetric = buildRuntimeMetric(runtimeState);
+    metrics.push(runtimeMetric.metric);
+    toolOutputs.push(runtimeMetric.toolOutput);
+    const validationMetric = buildValidationMetric(runtimeState);
+    metrics.push(validationMetric.metric);
+    toolOutputs.push(validationMetric.toolOutput);
+    const hygieneMetric = await buildRepoHygieneMetric(repoRoot);
+    metrics.push(hygieneMetric.metric);
+    toolOutputs.push(hygieneMetric.toolOutput);
+    const ecosystemMetrics = await buildEcosystemMetrics(repoRoot, ecosystems);
+    metrics.push(...ecosystemMetrics.metrics);
+    toolOutputs.push(...ecosystemMetrics.toolOutputs);
+    const totalScore = roundScore(metrics.reduce((sum, metric) => sum + metric.points, 0));
+    const maxScore = roundScore(metrics.reduce((sum, metric) => sum + metric.max_points, 0));
+    if (kind === 'final' && !(runtimeState.runtime.last_validation?.passed && (runtimeState.runtime.current_state === 'validate_complete' || runtimeState.runtime.current_state === 'completed'))) {
+        throw new ProdifyError('Final scoring requires a validated runtime state at validate_complete or completed.', {
+            code: 'SCORING_STATE_INVALID'
+        });
+    }
+    return {
+        snapshot: {
+            schema_version: SCORE_SCHEMA_VERSION,
+            kind,
+            ecosystems,
+            total_score: totalScore,
+            max_score: maxScore,
+            metrics
+        },
+        toolOutputs
+    };
+}
+function serializeJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+export async function writeScoreSnapshot(repoRoot, { kind, runtimeState }) {
+    const { snapshot, toolOutputs } = await calculateLocalScore(repoRoot, {
+        kind,
+        runtimeState
+    });
+    const metricsDir = resolveRepoPath(repoRoot, '.prodify/metrics');
+    await writeFileEnsuringDir(path.join(metricsDir, `${kind}.score.json`), serializeJson(snapshot));
+    await writeFileEnsuringDir(path.join(metricsDir, `${kind}.tools.json`), serializeJson({
+        schema_version: SCORE_SCHEMA_VERSION,
+        kind,
+        outputs: toolOutputs
+    }));
+    return snapshot;
+}
+export async function writeScoreDelta(repoRoot) {
+    const metricsDir = resolveRepoPath(repoRoot, '.prodify/metrics');
+    const baseline = JSON.parse(await fs.readFile(path.join(metricsDir, 'baseline.score.json'), 'utf8'));
+    const final = JSON.parse(await fs.readFile(path.join(metricsDir, 'final.score.json'), 'utf8'));
+    const delta = {
+        schema_version: SCORE_SCHEMA_VERSION,
+        baseline_score: baseline.total_score,
+        final_score: final.total_score,
+        delta: roundScore(final.total_score - baseline.total_score)
+    };
+    await writeFileEnsuringDir(path.join(metricsDir, 'delta.json'), serializeJson(delta));
+    return delta;
+}

package/dist/skills/loader.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs/promises';
+import { pathExists } from '../core/fs.js';
+import { resolveCanonicalPath } from '../core/paths.js';
+import { ProdifyError } from '../core/errors.js';
+import { validateSkillDefinitionShape, validateSkillRegistryManifest } from './schema.js';
+const SKILL_REGISTRY_PATH = '.prodify/skills/registry.json';
+async function readJsonFile(filePath, missingCode, invalidCode) {
+    if (!(await pathExists(filePath))) {
+        throw new ProdifyError(`Required skill file is missing: ${filePath}.`, {
+            code: missingCode
+        });
+    }
+    try {
+        return JSON.parse(await fs.readFile(filePath, 'utf8'));
+    }
+    catch {
+        throw new ProdifyError(`Skill file is malformed JSON: ${filePath}.`, {
+            code: invalidCode
+        });
+    }
+}
+export async function readSkillRegistryManifest(repoRoot) {
+    const registryPath = resolveCanonicalPath(repoRoot, SKILL_REGISTRY_PATH);
+    return validateSkillRegistryManifest(await readJsonFile(registryPath, 'SKILL_REGISTRY_MISSING', 'SKILL_REGISTRY_INVALID'));
+}
+export async function loadSkillRegistry(repoRoot) {
+    const manifest = await readSkillRegistryManifest(repoRoot);
+    const registry = new Map();
+    for (const relativePath of manifest.skills) {
+        const fullPath = resolveCanonicalPath(repoRoot, `.prodify/skills/${relativePath}`);
+        const definition = validateSkillDefinitionShape(await readJsonFile(fullPath, 'SKILL_DEFINITION_MISSING', 'SKILL_DEFINITION_INVALID'));
+        if (registry.has(definition.id)) {
+            throw new ProdifyError(`Duplicate skill id detected: ${definition.id}.`, {
+                code: 'SKILL_REGISTRY_INVALID'
+            });
+        }
+        registry.set(definition.id, definition);
+    }
+    return registry;
+}