vgxness 0.1.0

package/dist/skills/repositories/skill-evaluation-scenarios.js

@@ -0,0 +1,289 @@
+import { randomUUID } from 'node:crypto';
+export class SkillEvaluationScenarioRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createScenario(input) {
+        const validation = validateScenarioInput(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            assertSkillExists(this.db, input.skillId);
+            if (input.versionId !== undefined)
+                assertVersionBelongsToSkill(this.db, input.versionId, input.skillId);
+            if (input.proposalId !== undefined)
+                assertProposalBelongsToSkill(this.db, input.proposalId, input.skillId);
+            const normalizedName = normalizeScenarioName(input.name);
+            const proposalContextKey = input.proposalId ?? '';
+            const versionContextKey = input.versionId ?? '';
+            const duplicate = this.db.connection.prepare(`
+        SELECT id FROM skill_evaluation_scenarios
+        WHERE skill_id=? AND normalized_name=? AND proposal_context_key=? AND version_context_key=?
+      `).get(input.skillId, normalizedName, proposalContextKey, versionContextKey);
+            if (duplicate !== undefined)
+                throw new SkillEvaluationScenarioValidationError(`Skill evaluation scenario already exists: ${normalizedName}`);
+            const now = new Date().toISOString();
+            const id = randomUUID();
+            this.db.connection.prepare(`
+        INSERT INTO skill_evaluation_scenarios(
+          id, skill_id, name, normalized_name, criteria_json,
+          proposal_id, proposal_context_key, version_id, version_context_key,
+          created_by, created_at, updated_at
+        ) VALUES (
+          @id, @skillId, @name, @normalizedName, @criteriaJson,
+          @proposalId, @proposalContextKey, @versionId, @versionContextKey,
+          @createdBy, @createdAt, @updatedAt
+        )
+      `).run({
+                id,
+                skillId: input.skillId,
+                name: input.name.trim(),
+                normalizedName,
+                criteriaJson: JSON.stringify(input.criteria),
+                proposalId: input.proposalId ?? null,
+                proposalContextKey,
+                versionId: input.versionId ?? null,
+                versionContextKey,
+                createdBy: input.createdBy.trim(),
+                createdAt: now,
+                updatedAt: now,
+            });
+            const read = this.getScenario(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillEvaluationScenarioValidationError)
+            return validationFailure(result.error.cause.message);
+        return result;
+    }
+    listScenarios(filters) {
+        if (!filters.skillId.trim())
+            return validationFailure('Skill id is required');
+        try {
+            const where = ['skill_id=@skillId'];
+            const parameters = { skillId: filters.skillId };
+            if (filters.proposalId !== undefined) {
+                where.push('proposal_id=@proposalId');
+                parameters.proposalId = filters.proposalId;
+            }
+            if (filters.versionId !== undefined) {
+                where.push('version_id=@versionId');
+                parameters.versionId = filters.versionId;
+            }
+            const rows = this.db.connection.prepare(`
+        SELECT * FROM skill_evaluation_scenarios
+        WHERE ${where.join(' AND ')}
+        ORDER BY normalized_name ASC, created_at ASC, id ASC
+      `).all(parameters);
+            return ok(rows.map(mapScenario));
+        }
+        catch (cause) {
+            return fail('Failed to list skill evaluation scenarios', cause);
+        }
+    }
+    recordResult(input) {
+        const validation = validateResultInput(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const scenario = assertScenarioExists(this.db, input.scenarioId);
+            if (input.versionId !== undefined)
+                assertVersionBelongsToSkill(this.db, input.versionId, scenario.skill_id);
+            if (input.proposalId !== undefined)
+                assertProposalBelongsToSkill(this.db, input.proposalId, scenario.skill_id);
+            const now = new Date().toISOString();
+            const id = randomUUID();
+            this.db.connection.prepare(`
+        INSERT INTO skill_evaluation_results(
+          id, scenario_id, status, result_json, observed_behavior,
+          evaluator, proposal_id, version_id, notes, created_at
+        ) VALUES (
+          @id, @scenarioId, @status, @resultJson, @observedBehavior,
+          @evaluator, @proposalId, @versionId, @notes, @createdAt
+        )
+      `).run({
+                id,
+                scenarioId: input.scenarioId,
+                status: input.status,
+                resultJson: JSON.stringify(input.result),
+                observedBehavior: input.observedBehavior.trim(),
+                evaluator: input.evaluator.trim(),
+                proposalId: input.proposalId ?? null,
+                versionId: input.versionId ?? null,
+                notes: input.notes?.trim() ? input.notes.trim() : null,
+                createdAt: now,
+            });
+            const read = this.getResult(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillEvaluationScenarioValidationError)
+            return validationFailure(result.error.cause.message);
+        return result;
+    }
+    listResults(filters = {}) {
+        try {
+            const where = [];
+            const parameters = {};
+            if (filters.scenarioId !== undefined) {
+                where.push('results.scenario_id=@scenarioId');
+                parameters.scenarioId = filters.scenarioId;
+            }
+            if (filters.skillId !== undefined) {
+                where.push('scenarios.skill_id=@skillId');
+                parameters.skillId = filters.skillId;
+            }
+            if (filters.proposalId !== undefined) {
+                where.push('results.proposal_id=@proposalId');
+                parameters.proposalId = filters.proposalId;
+            }
+            if (filters.versionId !== undefined) {
+                where.push('results.version_id=@versionId');
+                parameters.versionId = filters.versionId;
+            }
+            if (filters.evaluator !== undefined) {
+                where.push('results.evaluator=@evaluator');
+                parameters.evaluator = filters.evaluator;
+            }
+            if (filters.status !== undefined) {
+                where.push('results.status=@status');
+                parameters.status = filters.status;
+            }
+            const rows = this.db.connection.prepare(`
+        SELECT results.* FROM skill_evaluation_results results
+        JOIN skill_evaluation_scenarios scenarios ON scenarios.id = results.scenario_id
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY results.created_at ASC, results.rowid ASC
+      `).all(parameters);
+            return ok(rows.map(mapResult));
+        }
+        catch (cause) {
+            return fail('Failed to list skill evaluation results', cause);
+        }
+    }
+    getScenario(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skill_evaluation_scenarios WHERE id=?').get(id);
+            return row ? ok(mapScenario(row)) : missing(`Skill evaluation scenario not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill evaluation scenario', cause);
+        }
+    }
+    getResult(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skill_evaluation_results WHERE id=?').get(id);
+            return row ? ok(mapResult(row)) : missing(`Skill evaluation result not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill evaluation result', cause);
+        }
+    }
+}
+function validateScenarioInput(input) {
+    if (!input.skillId.trim())
+        return validationFailure('Skill id is required');
+    if (!input.name.trim())
+        return validationFailure('Skill evaluation scenario name is required');
+    if (!isJsonObject(input.criteria))
+        return validationFailure('Skill evaluation scenario criteria must be a JSON object');
+    if (!input.createdBy.trim())
+        return validationFailure('Skill evaluation scenario creator is required');
+    return ok(undefined);
+}
+function validateResultInput(input) {
+    if (!input.scenarioId.trim())
+        return validationFailure('Skill evaluation scenario id is required');
+    if (!isEvaluationResultStatus(input.status))
+        return validationFailure(`Invalid skill evaluation result status: ${input.status}`);
+    if (!isJsonObject(input.result))
+        return validationFailure('Skill evaluation result must be a JSON object');
+    if (!input.observedBehavior.trim())
+        return validationFailure('Skill evaluation observed behavior is required');
+    if (!input.evaluator.trim())
+        return validationFailure('Skill evaluation result evaluator is required');
+    return ok(undefined);
+}
+function normalizeScenarioName(name) {
+    return name.trim().toLowerCase().replace(/\s+/g, ' ');
+}
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isEvaluationResultStatus(value) {
+    return value === 'passed' || value === 'failed' || value === 'needs-review' || value === 'not-applicable';
+}
+function assertScenarioExists(db, scenarioId) {
+    const row = db.connection.prepare('SELECT id, skill_id FROM skill_evaluation_scenarios WHERE id=?').get(scenarioId);
+    if (row === undefined)
+        throw new SkillEvaluationScenarioValidationError(`Skill evaluation scenario not found: ${scenarioId}`);
+    return row;
+}
+function assertSkillExists(db, skillId) {
+    const row = db.connection.prepare('SELECT 1 FROM skills WHERE id=?').get(skillId);
+    if (row === undefined)
+        throw new SkillEvaluationScenarioValidationError(`Skill not found: ${skillId}`);
+}
+function assertVersionBelongsToSkill(db, versionId, skillId) {
+    const row = db.connection.prepare('SELECT skill_id FROM skill_versions WHERE id=?').get(versionId);
+    if (row === undefined)
+        throw new SkillEvaluationScenarioValidationError(`Skill version not found: ${versionId}`);
+    if (row.skill_id !== skillId)
+        throw new SkillEvaluationScenarioValidationError('Skill version must belong to the evaluated skill');
+}
+function assertProposalBelongsToSkill(db, proposalId, skillId) {
+    const row = db.connection.prepare('SELECT skill_id FROM skill_improvement_proposals WHERE id=?').get(proposalId);
+    if (row === undefined)
+        throw new SkillEvaluationScenarioValidationError(`Skill improvement proposal not found: ${proposalId}`);
+    if (row.skill_id !== skillId)
+        throw new SkillEvaluationScenarioValidationError('Skill improvement proposal must belong to the evaluated skill');
+}
+function mapScenario(row) {
+    const scenario = {
+        id: row.id,
+        skillId: row.skill_id,
+        name: row.name,
+        normalizedName: row.normalized_name,
+        criteria: JSON.parse(row.criteria_json),
+        createdBy: row.created_by,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+    if (row.proposal_id !== null)
+        scenario.proposalId = row.proposal_id;
+    if (row.version_id !== null)
+        scenario.versionId = row.version_id;
+    return scenario;
+}
+function mapResult(row) {
+    const result = {
+        id: row.id,
+        scenarioId: row.scenario_id,
+        status: row.status,
+        result: JSON.parse(row.result_json),
+        observedBehavior: row.observed_behavior,
+        evaluator: row.evaluator,
+        createdAt: row.created_at,
+    };
+    if (row.proposal_id !== null)
+        result.proposalId = row.proposal_id;
+    if (row.version_id !== null)
+        result.versionId = row.version_id;
+    if (row.notes !== null)
+        result.notes = row.notes;
+    return result;
+}
+function ok(value) { return { ok: true, value }; }
+function missing(message) { return { ok: false, error: { code: 'not_found', message } }; }
+function validationFailure(message) { return { ok: false, error: { code: 'validation_failed', message } }; }
+function fail(message, cause) {
+    const error = { code: 'validation_failed', message };
+    if (cause !== undefined)
+        error.cause = cause;
+    return { ok: false, error };
+}
+class SkillEvaluationScenarioValidationError extends Error {
+}

package/dist/skills/repositories/skill-improvement-proposals.js

@@ -0,0 +1,288 @@
+import { randomUUID } from 'node:crypto';
+import { SkillRepository } from './skills.js';
+export class SkillImprovementProposalRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    create(input) {
+        const validation = validateCreate(input);
+        if (!validation.ok)
+            return validation;
+        const result = this.db.transaction(() => {
+            const base = assertBaseVersion(this.db, input.skillId, input.baseVersionId);
+            assertProposedVersionIsNew(this.db, input.skillId, input.proposedVersion);
+            const now = new Date().toISOString();
+            const id = randomUUID();
+            const proposedCompatibility = input.proposedCompatibility ?? base.compatibility;
+            const diffSummary = buildDiffSummary(base, input.proposedVersion, input.proposedSource, proposedCompatibility);
+            this.db.connection.prepare(`
+        INSERT INTO skill_improvement_proposals(
+          id, skill_id, base_version_id, proposed_version,
+          proposed_source_kind, proposed_source_path, proposed_source_url, proposed_source_inline_metadata_json,
+          proposed_compatibility_json, rationale, source_signal_json, diff_summary_json,
+          status, created_at, updated_at
+        ) VALUES (
+          @id, @skillId, @baseVersionId, @proposedVersion,
+          @sourceKind, @sourcePath, @sourceUrl, @sourceInlineMetadataJson,
+          @compatibilityJson, @rationale, @sourceSignalJson, @diffSummaryJson,
+          'draft', @createdAt, @updatedAt
+        )
+      `).run({
+                id,
+                skillId: input.skillId,
+                baseVersionId: input.baseVersionId,
+                proposedVersion: input.proposedVersion,
+                sourceKind: input.proposedSource.kind,
+                sourcePath: input.proposedSource.path ?? null,
+                sourceUrl: input.proposedSource.url ?? null,
+                sourceInlineMetadataJson: JSON.stringify(input.proposedSource.inlineMetadata ?? {}),
+                compatibilityJson: JSON.stringify(proposedCompatibility),
+                rationale: input.rationale,
+                sourceSignalJson: JSON.stringify(input.sourceSignal ?? {}),
+                diffSummaryJson: JSON.stringify(diffSummary),
+                createdAt: now,
+                updatedAt: now,
+            });
+            const read = this.getById(id);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillImprovementProposalValidationError)
+            return validationFailure(result.error.cause.message);
+        return result;
+    }
+    list(filters = {}) {
+        try {
+            const where = [];
+            const parameters = {};
+            if (filters.skillId !== undefined) {
+                where.push('skill_id=@skillId');
+                parameters.skillId = filters.skillId;
+            }
+            if (filters.status !== undefined) {
+                where.push('status=@status');
+                parameters.status = filters.status;
+            }
+            const rows = this.db.connection.prepare(`
+        SELECT * FROM skill_improvement_proposals
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY created_at DESC, id ASC
+      `).all(parameters);
+            return ok(rows.map(mapProposal));
+        }
+        catch (cause) {
+            return fail('Failed to list skill improvement proposals', cause);
+        }
+    }
+    getById(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM skill_improvement_proposals WHERE id=?').get(id);
+            return row ? ok(mapProposal(row)) : missing(`Skill improvement proposal not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read skill improvement proposal', cause);
+        }
+    }
+    submitForApproval(input) {
+        return this.transition(input, 'draft', 'pending-approval', 'submitted_at', 'submitted_by');
+    }
+    approve(input) {
+        return this.resolve(input, 'approved');
+    }
+    reject(input) {
+        return this.resolve(input, 'rejected');
+    }
+    cancel(input) {
+        const proposal = this.getById(input.proposalId);
+        if (!proposal.ok)
+            return proposal;
+        if (proposal.value.status !== 'draft' && proposal.value.status !== 'pending-approval')
+            return validationFailure(`Cannot cancel proposal with status ${proposal.value.status}`);
+        return this.resolve(input, 'cancelled', proposal.value.status);
+    }
+    apply(input) {
+        if (!input.actor.trim())
+            return validationFailure('Proposal actor is required');
+        const result = this.db.transaction(() => {
+            const proposal = this.getById(input.proposalId);
+            if (!proposal.ok)
+                throw new SkillImprovementProposalValidationError(proposal.error.message);
+            if (proposal.value.status !== 'approved')
+                throw new SkillImprovementProposalValidationError(`Cannot apply proposal with status ${proposal.value.status}`);
+            assertProposedVersionIsNew(this.db, proposal.value.skillId, proposal.value.proposedVersion);
+            const skills = new SkillRepository(this.db);
+            const version = skills.addVersion({
+                skillId: proposal.value.skillId,
+                version: proposal.value.proposedVersion,
+                source: proposal.value.proposedSource,
+                compatibility: proposal.value.proposedCompatibility,
+                activate: true,
+            });
+            if (!version.ok)
+                throw new SkillImprovementProposalValidationError(version.error.message);
+            const now = new Date().toISOString();
+            this.db.connection.prepare(`
+        UPDATE skill_improvement_proposals SET
+          status='applied', updated_at=@updatedAt, applied_at=@appliedAt, applied_by=@appliedBy,
+          apply_reason=@applyReason, applied_version_id=@appliedVersionId
+        WHERE id=@id
+      `).run({
+                id: input.proposalId,
+                updatedAt: now,
+                appliedAt: now,
+                appliedBy: input.actor,
+                applyReason: input.reason ?? null,
+                appliedVersionId: version.value.id,
+            });
+            const read = this.getById(input.proposalId);
+            if (!read.ok)
+                throw new Error(read.error.message);
+            return read.value;
+        });
+        if (!result.ok && result.error.cause instanceof SkillImprovementProposalValidationError)
+            return validationFailure(result.error.cause.message);
+        return result;
+    }
+    transition(input, from, to, atColumn, byColumn) {
+        if (!input.actor.trim())
+            return validationFailure('Proposal actor is required');
+        const proposal = this.getById(input.proposalId);
+        if (!proposal.ok)
+            return proposal;
+        if (proposal.value.status !== from)
+            return validationFailure(`Cannot move proposal from ${proposal.value.status} to ${to}`);
+        const now = new Date().toISOString();
+        try {
+            this.db.connection.prepare(`UPDATE skill_improvement_proposals SET status=?, updated_at=?, ${atColumn}=?, ${byColumn}=? WHERE id=?`).run(to, now, now, input.actor, input.proposalId);
+            return this.getById(input.proposalId);
+        }
+        catch (cause) {
+            return fail('Failed to update skill improvement proposal', cause);
+        }
+    }
+    resolve(input, status, expectedStatus = 'pending-approval') {
+        if (!input.actor.trim())
+            return validationFailure('Proposal actor is required');
+        const proposal = this.getById(input.proposalId);
+        if (!proposal.ok)
+            return proposal;
+        if (proposal.value.status !== expectedStatus)
+            return validationFailure(`Cannot ${status} proposal with status ${proposal.value.status}`);
+        const now = new Date().toISOString();
+        try {
+            this.db.connection.prepare(`
+        UPDATE skill_improvement_proposals SET
+          status=@status, updated_at=@updatedAt, resolved_at=@resolvedAt,
+          resolved_by=@resolvedBy, resolution_reason=@resolutionReason
+        WHERE id=@id
+      `).run({
+                id: input.proposalId,
+                status,
+                updatedAt: now,
+                resolvedAt: now,
+                resolvedBy: input.actor,
+                resolutionReason: input.reason ?? null,
+            });
+            return this.getById(input.proposalId);
+        }
+        catch (cause) {
+            return fail('Failed to resolve skill improvement proposal', cause);
+        }
+    }
+}
+function validateCreate(input) {
+    if (!input.skillId.trim())
+        return validationFailure('Skill id is required');
+    if (!input.baseVersionId.trim())
+        return validationFailure('Base version id is required');
+    if (!input.proposedVersion.trim())
+        return validationFailure('Proposed version is required');
+    if (!input.rationale.trim())
+        return validationFailure('Proposal rationale is required');
+    if (input.proposedSource.kind === 'path' && !input.proposedSource.path?.trim())
+        return validationFailure('Path proposal sources require proposedSource.path');
+    if (input.proposedSource.kind === 'url' && !input.proposedSource.url?.trim())
+        return validationFailure('URL proposal sources require proposedSource.url');
+    if (input.proposedSource.kind === 'inline' && (input.proposedSource.path !== undefined || input.proposedSource.url !== undefined))
+        return validationFailure('Inline proposal sources cannot include path or url');
+    return ok(undefined);
+}
+function assertBaseVersion(db, skillId, baseVersionId) {
+    const base = new SkillRepository(db).getVersion(baseVersionId);
+    if (!base.ok)
+        throw new SkillImprovementProposalValidationError(base.error.message);
+    if (base.value.skillId !== skillId)
+        throw new SkillImprovementProposalValidationError('Base version must belong to the proposed skill');
+    return base.value;
+}
+function assertProposedVersionIsNew(db, skillId, proposedVersion) {
+    const existing = db.connection.prepare('SELECT 1 FROM skill_versions WHERE skill_id=? AND version=?').get(skillId, proposedVersion);
+    if (existing !== undefined)
+        throw new SkillImprovementProposalValidationError(`Proposed version already exists for skill: ${proposedVersion}`);
+}
+function buildDiffSummary(base, proposedVersion, proposedSource, proposedCompatibility) {
+    const changes = [];
+    if (base.version !== proposedVersion)
+        changes.push({ field: 'version', before: base.version, after: proposedVersion });
+    if (JSON.stringify(base.source) !== JSON.stringify(proposedSource))
+        changes.push({ field: 'source', before: base.source, after: proposedSource });
+    if (JSON.stringify(base.compatibility) !== JSON.stringify(proposedCompatibility))
+        changes.push({ field: 'compatibility', before: base.compatibility, after: proposedCompatibility });
+    return { baseVersionId: base.id, proposedVersion, changes };
+}
+function mapProposal(row) {
+    const proposedSource = { kind: row.proposed_source_kind };
+    if (row.proposed_source_path !== null)
+        proposedSource.path = row.proposed_source_path;
+    if (row.proposed_source_url !== null)
+        proposedSource.url = row.proposed_source_url;
+    const inlineMetadata = JSON.parse(row.proposed_source_inline_metadata_json ?? '{}');
+    if (Object.keys(inlineMetadata).length > 0)
+        proposedSource.inlineMetadata = inlineMetadata;
+    const proposal = {
+        id: row.id,
+        skillId: row.skill_id,
+        baseVersionId: row.base_version_id,
+        proposedVersion: row.proposed_version,
+        proposedSource,
+        proposedCompatibility: JSON.parse(row.proposed_compatibility_json),
+        rationale: row.rationale,
+        sourceSignal: JSON.parse(row.source_signal_json),
+        diffSummary: JSON.parse(row.diff_summary_json),
+        status: row.status,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+    if (row.submitted_at !== null)
+        proposal.submittedAt = row.submitted_at;
+    if (row.submitted_by !== null)
+        proposal.submittedBy = row.submitted_by;
+    if (row.resolved_at !== null)
+        proposal.resolvedAt = row.resolved_at;
+    if (row.resolved_by !== null)
+        proposal.resolvedBy = row.resolved_by;
+    if (row.resolution_reason !== null)
+        proposal.resolutionReason = row.resolution_reason;
+    if (row.applied_at !== null)
+        proposal.appliedAt = row.applied_at;
+    if (row.applied_by !== null)
+        proposal.appliedBy = row.applied_by;
+    if (row.apply_reason !== null)
+        proposal.applyReason = row.apply_reason;
+    if (row.applied_version_id !== null)
+        proposal.appliedVersionId = row.applied_version_id;
+    return proposal;
+}
+function ok(value) { return { ok: true, value }; }
+function missing(message) { return { ok: false, error: { code: 'not_found', message } }; }
+function validationFailure(message) { return { ok: false, error: { code: 'validation_failed', message } }; }
+function fail(message, cause) {
+    const error = { code: 'validation_failed', message };
+    if (cause !== undefined)
+        error.cause = cause;
+    return { ok: false, error };
+}
+class SkillImprovementProposalValidationError extends Error {
+}