vgxness 1.20.4 → 1.20.6

package/dist/skills/schema.js

@@ -1 +1 @@
-export {};
+export * from '../domain/skills/schema.js';

package/dist/skills/skill-export-service.js

@@ -1,34 +1 @@
-export class SkillExportService {
-    index;
-    constructor(index) {
-        this.index = index;
-    }
-    export(input) {
-        const indexed = this.index.getIndex(input);
-        if (!indexed.ok)
-            return indexed;
-        return {
-            ok: true,
-            value: {
-                kind: 'vgxness.skills-export',
-                version: 1,
-                project: indexed.value.project,
-                scope: indexed.value.scope,
-                totals: indexed.value.totals,
-                skills: indexed.value.skills,
-                diagnostics: indexed.value.diagnostics,
-                safety: {
-                    readOnly: true,
-                    providerConfigWrites: false,
-                    opencodeWrites: false,
-                    claudeWrites: false,
-                    nativeSkillFileWrites: false,
-                    urlFetches: false,
-                    usageRecords: false,
-                    seedLoaded: false,
-                    bootUpgradeSideEffects: false,
-                },
-            },
-        };
-    }
-}
+export * from '../application/skills/skill-export-service.js';

package/dist/skills/skill-index-service.js

@@ -1,126 +1 @@
-import { dedupeSkillSummariesByName, skillIndexContexts } from './personal-skills.js';
-export class SkillIndexService {
-    registry;
-    constructor(registry) {
-        this.registry = registry;
-    }
-    getIndex(input) {
-        const listed = this.listSkills(input);
-        if (!listed.ok)
-            return listed;
-        const skills = [];
-        for (const summary of [...listed.value].sort(compareSkillSummariesById)) {
-            const details = this.registry.getSkillDetails(summary.id);
-            if (!details.ok)
-                return details;
-            skills.push(indexSkill(details.value));
-        }
-        const active = skills.filter((skill) => skill.status === 'active').length;
-        return {
-            ok: true,
-            value: {
-                project: input.project,
-                scope: input.scope,
-                totals: {
-                    skills: skills.length,
-                    active,
-                    inactive: skills.length - active,
-                    previewOnly: skills.length,
-                },
-                skills,
-                diagnostics: topLevelDiagnostics(),
-                safety: {
-                    readOnly: true,
-                    providerConfigWrites: false,
-                    opencodeWrites: false,
-                    nativeSkillFileWrites: false,
-                    urlFetches: false,
-                    usageRecords: false,
-                    opencodeStartupRefresh: false,
-                    opencodePluginRefresh: false,
-                },
-            },
-        };
-    }
-    listSkills(input) {
-        const skills = [];
-        for (const context of skillIndexContexts(input.project, input.scope)) {
-            const listed = this.registry.listSkills({ project: context.project, scope: context.scope });
-            if (!listed.ok)
-                return listed;
-            skills.push(...listed.value);
-        }
-        return { ok: true, value: dedupeSkillSummariesByName(skills) };
-    }
-}
-function indexSkill(details) {
-    const currentVersion = details.currentVersion;
-    const status = currentVersion?.status ?? (details.currentVersionId === undefined ? 'missing-current-version' : 'missing-current-version-record');
-    return {
-        id: details.id,
-        name: details.name,
-        activeVersion: currentVersion?.status === 'active' ? currentVersion.version : null,
-        status,
-        sourceKind: currentVersion?.source.kind ?? null,
-        attachments: {
-            count: details.attachments.length,
-            kinds: [...new Set(details.attachments.map((attachment) => attachment.targetType))].sort(),
-        },
-        safety: {
-            providerNativeInstall: 'unsupported',
-            opencodeLoading: 'preview-only',
-            writesProviderConfig: false,
-        },
-        diagnostics: skillDiagnostics(details.name, status),
-    };
-}
-function topLevelDiagnostics() {
-    return [
-        {
-            code: 'SKILL_PROVIDER_NATIVE_UNSUPPORTED',
-            severity: 'info',
-            message: 'Native provider skill installation is unsupported by the skills index command.',
-        },
-        {
-            code: 'SKILL_PROVIDER_PREVIEW_ONLY',
-            severity: 'info',
-            message: 'OpenCode skill loading is preview-only; no startup or plugin refresh is attempted.',
-        },
-    ];
-}
-function skillDiagnostics(skill, status) {
-    const diagnostics = [
-        {
-            code: 'SKILL_PROVIDER_NATIVE_UNSUPPORTED',
-            severity: 'info',
-            skill,
-            message: 'Native provider skill installation is unsupported for this skill index record.',
-        },
-        {
-            code: 'SKILL_PROVIDER_PREVIEW_ONLY',
-            severity: 'info',
-            skill,
-            message: 'OpenCode loading is preview-only for this skill index record.',
-        },
-    ];
-    if (status === 'missing-current-version' || status === 'missing-current-version-record') {
-        diagnostics.push({
-            code: 'SKILL_CURRENT_VERSION_MISSING',
-            severity: 'warning',
-            skill,
-            message: status === 'missing-current-version' ? 'Skill has no current version selected.' : 'Skill current version record is missing.',
-        });
-    }
-    else if (status !== 'active') {
-        diagnostics.push({
-            code: 'SKILL_INACTIVE',
-            severity: 'warning',
-            skill,
-            message: `Skill current version is ${status}, not active.`,
-        });
-    }
-    return diagnostics;
-}
-function compareSkillSummariesById(a, b) {
-    return a.id.localeCompare(b.id);
-}
+export * from '../application/skills/skill-index-service.js';

package/dist/skills/skill-payload.js

@@ -1,186 +1 @@
-import { createHash } from 'node:crypto';
-import { readFileSync, realpathSync, statSync } from 'node:fs';
-import { isAbsolute, relative, resolve } from 'node:path';
-const defaultMaxSourceBytes = 64 * 1024;
-export function buildSkillInjectionPayload(resolution, options = {}) {
-    const workspaceRoot = options.workspaceRoot !== undefined ? safeRealpath(options.workspaceRoot) : undefined;
-    if (options.workspaceRoot !== undefined && workspaceRoot === undefined)
-        return validationFailure(`Workspace root is unavailable: ${options.workspaceRoot}`);
-    const maxSourceBytes = options.maxSourceBytes ?? defaultMaxSourceBytes;
-    const mode = options.mode ?? 'compact';
-    const items = resolution.skills.map((skill, index) => toPayloadItem(skill, index, workspaceRoot, maxSourceBytes, mode));
-    const skillDiagnostics = payloadDiagnostics(resolution.skillDiagnostics, items);
-    return {
-        ok: true,
-        value: {
-            version: 1,
-            providerAgnostic: true,
-            context: resolution.context,
-            items,
-            skipped: resolution.skipped,
-            skillDiagnostics,
-            warnings: [
-                'Skill payload v1 is injection-ready data only; it does not mutate provider configuration or fetch URL sources.',
-                ...(mode === 'compact' ? ['Skill payload uses compact mode by default; request mode=verbose for full inline/path content when safe.'] : []),
-                ...(resolution.warnings ?? []),
-            ],
-        },
-    };
-}
-function payloadDiagnostics(base, items) {
-    const diagnostics = [...base.diagnostics];
-    const itemByName = new Map(items.map((item) => [item.identity.name, item]));
-    const skills = base.skills.map((status) => {
-        if (!status.included)
-            return status;
-        const item = itemByName.get(status.name);
-        if (item === undefined)
-            return status;
-        if (item.content.status === 'available')
-            return { ...status, payloadState: 'ready' };
-        diagnostics.push({
-            code: 'SKILL_PAYLOAD_UNAVAILABLE',
-            severity: 'warning',
-            skill: status.name,
-            message: `Skill ${status.name} resolved from the registry, but preview content is unavailable: ${item.content.unavailableReason ?? 'unknown'}.`,
-            details: {
-                registryState: status.registryState,
-                payloadState: 'unavailable',
-                providerState: status.providerState,
-                unavailableReason: item.content.unavailableReason ?? 'unknown',
-            },
-        });
-        return { ...status, payloadState: 'unavailable', reason: item.content.unavailableReason ?? 'content_unavailable' };
-    });
-    return {
-        ...base,
-        skills,
-        diagnostics,
-        summary: {
-            declared: skills.length,
-            resolved: skills.filter((skill) => skill.included).length,
-            skipped: skills.filter((skill) => !skill.included).length,
-            warnings: diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length,
-            errors: diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length,
-        },
-    };
-}
-function toPayloadItem(skill, index, workspaceRoot, maxSourceBytes, mode) {
-    const loaded = loadContent(skill, workspaceRoot, maxSourceBytes, mode);
-    return {
-        identity: {
-            skillId: skill.skillId,
-            name: skill.name,
-            description: skill.description,
-            versionId: skill.versionId,
-            version: skill.version,
-        },
-        source: {
-            kind: skill.source.kind,
-            ...(skill.source.path !== undefined ? { path: skill.source.path } : {}),
-            ...(skill.source.url !== undefined ? { url: skill.source.url } : {}),
-        },
-        content: loaded,
-        attachmentReasons: skill.attachmentSources,
-        ordering: {
-            index,
-            dedupeKey: skill.skillId,
-            attachmentSourceCount: skill.attachmentSources.length,
-        },
-    };
-}
-function loadContent(skill, workspaceRoot, maxSourceBytes, mode) {
-    if (skill.source.kind === 'inline') {
-        if (skill.content !== undefined)
-            return inlineContentPayload(skill.content, skill.summary, inlineRef(skill), maxSourceBytes, mode);
-        if (skill.summary !== undefined)
-            return inlineContentPayload(skill.summary, skill.summary, inlineRef(skill), maxSourceBytes, mode);
-        return { status: 'unavailable', unavailableReason: 'inline_content_missing' };
-    }
-    if (skill.source.kind === 'url')
-        return { status: 'unavailable', unavailableReason: 'url_fetch_disabled' };
-    if (workspaceRoot === undefined)
-        return { status: 'unavailable', unavailableReason: 'workspace_root_required' };
-    if (skill.source.path === undefined || !skill.source.path.trim())
-        return { status: 'unavailable', unavailableReason: 'path_missing' };
-    const requested = isAbsolute(skill.source.path) ? skill.source.path : resolve(workspaceRoot, skill.source.path);
-    if (!isWithinRoot(requested, workspaceRoot))
-        return { status: 'unavailable', unavailableReason: 'path_outside_workspace' };
-    const real = safeRealpath(requested);
-    if (real === undefined)
-        return { status: 'unavailable', unavailableReason: 'path_not_found' };
-    if (!isWithinRoot(real, workspaceRoot))
-        return { status: 'unavailable', unavailableReason: 'path_outside_workspace' };
-    try {
-        const stats = statSync(real);
-        if (!stats.isFile())
-            return { status: 'unavailable', unavailableReason: 'path_not_file' };
-        if (mode === 'compact')
-            return compactPathContent(skill, stats.size);
-        if (stats.size > maxSourceBytes)
-            return { status: 'unavailable', unavailableReason: 'path_too_large', byteSize: stats.size, ref: skill.source.path };
-        return contentPayload(readFileSync(real, 'utf8'), skill.summary, skill.source.path, mode, stats.size);
-    }
-    catch {
-        return { status: 'unavailable', unavailableReason: 'path_read_failed' };
-    }
-}
-function inlineContentPayload(value, summary, ref, maxSourceBytes, mode) {
-    const byteSize = Buffer.byteLength(value, 'utf8');
-    if (mode === 'verbose' && byteSize > maxSourceBytes) {
-        return { status: 'unavailable', unavailableReason: 'inline_too_large', byteSize, ...(ref === undefined ? {} : { ref }) };
-    }
-    return contentPayload(value, summary, ref, mode, byteSize);
-}
-function compactPathContent(skill, byteSize) {
-    const metadataHash = stringMetadata(skill.sourceMetadata.sha256) ?? stringMetadata(skill.sourceMetadata.hash) ?? stringMetadata(skill.sourceMetadata.contentHash);
-    const metadataSummary = skill.summary ?? stringMetadata(skill.sourceMetadata.summary);
-    return {
-        status: 'available',
-        contentAvailable: true,
-        byteSize,
-        ...(metadataHash === undefined ? {} : { hash: metadataHash }),
-        summary: summarize(metadataSummary ?? `Path skill source available at ${skill.source.path ?? 'unknown path'} (${byteSize} bytes).`),
-        ...(skill.source.path === undefined ? {} : { ref: skill.source.path }),
-    };
-}
-function contentPayload(value, summary, ref, mode, byteSize = Buffer.byteLength(value, 'utf8')) {
-    if (mode === 'verbose')
-        return { status: 'available', value, byteSize, hash: sha256(value), ...(ref === undefined ? {} : { ref }) };
-    return {
-        status: 'available',
-        contentAvailable: true,
-        byteSize,
-        hash: sha256(value),
-        summary: summarize(summary ?? value),
-        ...(ref === undefined ? {} : { ref }),
-    };
-}
-function inlineRef(skill) {
-    return `skill:${skill.name}@${skill.version}`;
-}
-function sha256(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function summarize(value) {
-    const normalized = value.replace(/\s+/g, ' ').trim();
-    return normalized.length <= 240 ? normalized : `${normalized.slice(0, 237)}...`;
-}
-function stringMetadata(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
-}
-function safeRealpath(path) {
-    try {
-        return realpathSync(path);
-    }
-    catch {
-        return undefined;
-    }
-}
-function isWithinRoot(path, root) {
-    const relation = relative(root, path);
-    return relation === '' || (!relation.startsWith('..') && !isAbsolute(relation));
-}
-function validationFailure(message) {
-    return { ok: false, error: { code: 'validation_failed', message } };
-}
+export * from '../application/skills/skill-payload.js';