vgxness 1.20.4 → 1.20.6

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

@@ -1,147 +1 @@
-import { dedupeSkillSummariesByName, skillIndexContexts } from './personal-skills.js';
-export class SkillStatusService {
-    skills;
-    agents;
-    constructor(skills, agents) {
-        this.skills = skills;
-        this.agents = agents;
-    }
-    getStatus(input) {
-        const scope = input.scope ?? 'project';
-        const provider = input.provider ?? 'opencode';
-        const modes = input.mode === undefined ? ['agent', 'subagent'] : [input.mode];
-        const diagnostics = [];
-        const registry = this.skillRegistry(input.project, scope);
-        if (!registry.ok)
-            return registry;
-        const selectedAgents = this.selectAgents(input.project, scope, modes, input.agent, diagnostics);
-        if (!selectedAgents.ok)
-            return selectedAgents;
-        const agentItems = [];
-        for (const agent of selectedAgents.value) {
-            const resolved = this.skills.resolveSkills({ agentId: agent.id, project: input.project, scope, providerAdapter: provider });
-            if (!resolved.ok)
-                return resolved;
-            const resolvedNames = resolved.value.skills.map((skill) => skill.name).sort(compareStrings);
-            const declared = [...agent.skills].sort(compareStrings);
-            const missing = declared.filter((name) => !resolvedNames.includes(name));
-            agentItems.push({
-                id: agent.id,
-                name: agent.name,
-                mode: agent.mode,
-                declaredSkills: declared,
-                resolvedSkills: resolvedNames,
-                missingSkills: missing,
-                diagnostics: resolved.value.skillDiagnostics.diagnostics,
-            });
-            diagnostics.push(...resolved.value.skillDiagnostics.diagnostics);
-        }
-        const declared = agentItems.reduce((sum, item) => sum + item.declaredSkills.length, 0);
-        const resolved = agentItems.reduce((sum, item) => sum + item.resolvedSkills.length, 0);
-        const missing = agentItems.reduce((sum, item) => sum + item.missingSkills.length, 0);
-        const v2Counts = this.skills.skills.getV2Counts(input.project, scope);
-        if (!v2Counts.ok)
-            return v2Counts;
-        return ok({
-            kind: 'skills-status',
-            version: 1,
-            project: input.project,
-            scope,
-            provider,
-            providerMode: 'preview-only',
-            providerState: 'preview-only',
-            mode: input.mode ?? 'all',
-            agent: input.agent ?? null,
-            context: {
-                project: input.project,
-                scope,
-                provider,
-                providerMode: 'preview-only',
-                providerState: 'preview-only',
-                ...(input.mode !== undefined ? { mode: input.mode } : {}),
-                ...(input.agent !== undefined ? { agent: input.agent } : {}),
-            },
-            skills: registry.value.items.map((skill) => ({
-                ...skill,
-                registered: true,
-                active: skill.status === 'active',
-                current: skill.currentVersionId !== null && skill.currentVersion !== null,
-                providerAvailable: false,
-            })),
-            registry: { skills: registry.value, v2: v2Counts.value },
-            agents: { modes, declared, resolved, missing, items: agentItems },
-            diagnostics,
-            safety: {
-                readOnly: true,
-                previewOnly: true,
-                providerWrites: false,
-                usageRecorded: false,
-                repairAttempted: false,
-                installAttempted: false,
-                providerRepair: false,
-                providerInstall: false,
-                usageRecording: false,
-            },
-        });
-    }
-    skillRegistry(project, scope) {
-        const listedSkills = [];
-        for (const context of skillIndexContexts(project, scope)) {
-            const listed = this.skills.listSkills({ project: context.project, scope: context.scope });
-            if (!listed.ok)
-                return listed;
-            listedSkills.push(...listed.value);
-        }
-        const summaries = dedupeSkillSummariesByName(listedSkills);
-        const items = [];
-        for (const skill of summaries) {
-            const details = this.skills.getSkillDetails(skill.id);
-            if (!details.ok)
-                return details;
-            const currentVersion = details.value.currentVersion;
-            items.push({
-                id: skill.id,
-                name: skill.name,
-                description: skill.description,
-                source: currentVersion?.source ?? null,
-                currentVersionId: skill.currentVersionId ?? null,
-                currentVersion: currentVersion?.version ?? null,
-                status: currentVersion?.status ?? (skill.currentVersionId === undefined ? 'missing-current-version' : 'missing-current-version-record'),
-                attachments: details.value.attachments.length,
-            });
-        }
-        const active = items.filter((item) => item.status === 'active').length;
-        return ok({ total: items.length, active, inactive: items.length - active, items });
-    }
-    selectAgents(project, scope, modes, agentQuery, diagnostics) {
-        const selected = [];
-        for (const mode of modes) {
-            const listed = this.agents.listAgents({ project, scope, mode });
-            if (!listed.ok)
-                return listed;
-            for (const summary of listed.value) {
-                if (agentQuery !== undefined && summary.id !== agentQuery && summary.name !== agentQuery)
-                    continue;
-                const agent = this.agents.getAgent(summary.id);
-                if (!agent.ok)
-                    return agent;
-                selected.push(agent.value);
-            }
-        }
-        if (agentQuery !== undefined && selected.length === 0) {
-            diagnostics.push({
-                code: 'SKILL_ATTACHMENT_MISSING',
-                severity: 'warning',
-                message: `No agent or subagent matched ${agentQuery} in ${project}/${scope}.`,
-                details: { agent: agentQuery, modes },
-            });
-        }
-        return ok(selected.sort((a, b) => compareStrings(`${a.mode}:${a.name}:${a.id}`, `${b.mode}:${b.name}:${b.id}`)));
-    }
-}
-function compareStrings(a, b) {
-    return a.localeCompare(b);
-}
-function ok(value) {
-    return { ok: true, value };
-}
+export * from '../application/skills/skill-status-service.js';

package/dist/storage/agents/repositories/agent-seed-history.js

@@ -0,0 +1,128 @@
+import { randomUUID } from 'node:crypto';
+export class AgentSeedHistoryRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    append(input) {
+        const validation = validate(input);
+        if (!validation.ok)
+            return validation;
+        try {
+            const id = randomUUID();
+            const appliedAt = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO agent_seed_history(id, applied_at, from_version, to_version, agent_name, project, scope, outcome, reason, source)
+        VALUES (@id, @appliedAt, @fromVersion, @toVersion, @agentName, @project, @scope, @outcome, @reason, @source)
+      `)
+                .run({
+                id,
+                appliedAt,
+                fromVersion: input.fromVersion,
+                toVersion: input.toVersion,
+                agentName: input.agentName,
+                project: input.project,
+                scope: input.scope,
+                outcome: input.outcome,
+                reason: input.reason ?? null,
+                source: input.source,
+            });
+            const entry = {
+                id,
+                appliedAt,
+                fromVersion: input.fromVersion,
+                toVersion: input.toVersion,
+                agentName: input.agentName,
+                project: input.project,
+                scope: input.scope,
+                outcome: input.outcome,
+                reason: input.reason ?? null,
+                source: input.source,
+            };
+            return ok(entry);
+        }
+        catch (cause) {
+            return fail('Failed to append agent_seed_history entry', cause);
+        }
+    }
+    listRecent(filters = {}) {
+        try {
+            const where = [];
+            const parameters = {};
+            for (const [key, column] of [
+                ['project', 'project'],
+                ['scope', 'scope'],
+                ['agentName', 'agent_name'],
+            ]) {
+                const value = filters[key];
+                if (value !== undefined) {
+                    where.push(`${column}=@${key}`);
+                    parameters[key] = value;
+                }
+            }
+            const limit = Math.max(1, Math.min(filters.limit ?? 100, 1000));
+            const rows = this.db.connection
+                .prepare(`
+        SELECT * FROM agent_seed_history
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY applied_at DESC
+        LIMIT ${limit}
+      `)
+                .all(parameters);
+            return ok(rows.map(map));
+        }
+        catch (cause) {
+            return fail('Failed to list agent_seed_history entries', cause);
+        }
+    }
+}
+function validate(input) {
+    if (!input.project.trim())
+        return validationFailure('agent_seed_history project is required');
+    if (input.scope !== 'project' && input.scope !== 'personal')
+        return validationFailure('agent_seed_history scope is invalid');
+    if (!input.agentName.trim())
+        return validationFailure('agent_seed_history agentName is required');
+    if (!Number.isInteger(input.toVersion) || input.toVersion <= 0)
+        return validationFailure('agent_seed_history toVersion must be a positive integer');
+    if (input.fromVersion !== null && (!Number.isInteger(input.fromVersion) || input.fromVersion < 0))
+        return validationFailure('agent_seed_history fromVersion must be null or non-negative integer');
+    if (!input.source.trim())
+        return validationFailure('agent_seed_history source is required');
+    if (input.outcome !== 'created' &&
+        input.outcome !== 'upgraded' &&
+        input.outcome !== 'noop' &&
+        input.outcome !== 'overwrote-custom-instructions' &&
+        input.outcome !== 'validation_failed' &&
+        input.outcome !== 'db_error') {
+        return validationFailure(`agent_seed_history outcome is invalid: ${input.outcome}`);
+    }
+    return ok(undefined);
+}
+function map(row) {
+    return {
+        id: String(row.id),
+        appliedAt: String(row.applied_at),
+        fromVersion: row.from_version === null || row.from_version === undefined ? null : Number(row.from_version),
+        toVersion: Number(row.to_version),
+        agentName: String(row.agent_name),
+        project: String(row.project),
+        scope: row.scope,
+        outcome: String(row.outcome),
+        reason: row.reason === null || row.reason === undefined ? null : String(row.reason),
+        source: String(row.source),
+    };
+}
+function ok(value) {
+    return { ok: true, value };
+}
+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 };
+}

package/dist/storage/agents/repositories/agents.js

@@ -0,0 +1,200 @@
+import { randomUUID } from 'node:crypto';
+export class AgentRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    register(input) {
+        const validation = validate(input);
+        if (!validation.ok)
+            return validation;
+        const parentValidation = input.mode === 'subagent' ? this.validateParent(input) : ok(undefined);
+        if (!parentValidation.ok)
+            return parentValidation;
+        const result = this.db.transaction(() => {
+            const existing = this.findByNaturalKey(input.project, input.scope, input.name);
+            if (existing !== undefined && existing.mode !== input.mode) {
+                throw new AgentRegistryValidationError(`Agent already exists as ${existing.mode}: ${input.project}/${input.scope}/${input.name}`);
+            }
+            const id = existing?.id ?? randomUUID();
+            const now = new Date().toISOString();
+            const parameters = toRowParameters(input, id, existing?.created_at ?? now, now);
+            this.db.connection
+                .prepare(`
+        INSERT INTO agents(id, project, scope, mode, name, description, instructions_json, capabilities_json, permissions_json, memory_json, workflows_json, skills_json, adapters_json, parent_agent_id, created_at, updated_at)
+        VALUES (@id, @project, @scope, @mode, @name, @description, @instructionsJson, @capabilitiesJson, @permissionsJson, @memoryJson, @workflowsJson, @skillsJson, @adaptersJson, @parentAgentId, @createdAt, @updatedAt)
+        ON CONFLICT(project, scope, name) DO UPDATE SET
+          mode=excluded.mode,
+          description=excluded.description,
+          instructions_json=excluded.instructions_json,
+          capabilities_json=excluded.capabilities_json,
+          permissions_json=excluded.permissions_json,
+          memory_json=excluded.memory_json,
+          workflows_json=excluded.workflows_json,
+          skills_json=excluded.skills_json,
+          adapters_json=excluded.adapters_json,
+          parent_agent_id=excluded.parent_agent_id,
+          updated_at=excluded.updated_at
+      `)
+                .run(parameters);
+            const found = this.getById(id);
+            if (!found.ok)
+                throw new Error(found.error.message);
+            return found.value;
+        });
+        if (!result.ok && result.error.cause instanceof AgentRegistryValidationError) {
+            return validationFailure(result.error.cause.message);
+        }
+        return result;
+    }
+    getById(id) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM agents WHERE id=?').get(id);
+            return row ? ok(map(row)) : missing(`Agent not found: ${id}`);
+        }
+        catch (cause) {
+            return fail('Failed to read agent', cause);
+        }
+    }
+    getByName(project, scope, name) {
+        try {
+            const row = this.findByNaturalKey(project, scope, name);
+            return row ? ok(map(row)) : missing(`Agent not found: ${project}/${scope}/${name}`);
+        }
+        catch (cause) {
+            return fail('Failed to read agent by name', cause);
+        }
+    }
+    list(filters = {}) {
+        try {
+            const where = [];
+            const parameters = {};
+            for (const [key, column] of [
+                ['project', 'project'],
+                ['scope', 'scope'],
+                ['mode', 'mode'],
+                ['parentAgentId', 'parent_agent_id'],
+            ]) {
+                const value = filters[key];
+                if (value !== undefined) {
+                    where.push(`${column}=@${key}`);
+                    parameters[key] = value;
+                }
+            }
+            const rows = this.db.connection
+                .prepare(`
+        SELECT * FROM agents
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY name ASC
+      `)
+                .all(parameters);
+            return ok(rows.map((row) => toSummary(map(row))));
+        }
+        catch (cause) {
+            return fail('Failed to list agents', cause);
+        }
+    }
+    findByNaturalKey(project, scope, name) {
+        return this.db.connection.prepare('SELECT * FROM agents WHERE project=? AND scope=? AND name=?').get(project, scope, name);
+    }
+    validateParent(input) {
+        if (input.parentAgentId === undefined)
+            return validationFailure('Subagents require parentAgentId');
+        const parent = this.getById(input.parentAgentId);
+        if (!parent.ok)
+            return validationFailure(parent.error.message);
+        if (parent.value.mode !== 'agent')
+            return validationFailure('Subagent parent must be an agent');
+        if (parent.value.project !== input.project || parent.value.scope !== input.scope)
+            return validationFailure('Subagent parent must share project and scope');
+        return ok(undefined);
+    }
+}
+function validate(input) {
+    if (!input.project.trim())
+        return validationFailure('Agent project is required');
+    if (!input.name.trim())
+        return validationFailure('Agent name is required');
+    if (!input.description.trim())
+        return validationFailure('Agent description is required');
+    if (!input.instructions.value.trim())
+        return validationFailure('Agent instructions are required');
+    if (input.mode === 'agent' && input.parentAgentId !== undefined)
+        return validationFailure('Top-level agents cannot have parentAgentId');
+    return ok(undefined);
+}
+function toRowParameters(input, id, createdAt, updatedAt) {
+    return {
+        id,
+        project: input.project,
+        scope: input.scope,
+        mode: input.mode,
+        name: input.name,
+        description: input.description,
+        instructionsJson: JSON.stringify(input.instructions),
+        capabilitiesJson: JSON.stringify(input.capabilities ?? []),
+        permissionsJson: JSON.stringify(input.permissions ?? {}),
+        memoryJson: JSON.stringify(input.memory ?? { scopes: [] }),
+        workflowsJson: JSON.stringify(input.workflows ?? []),
+        skillsJson: JSON.stringify(input.skills ?? []),
+        adaptersJson: JSON.stringify(input.adapters ?? {}),
+        parentAgentId: input.parentAgentId ?? null,
+        createdAt,
+        updatedAt,
+    };
+}
+function map(row) {
+    const value = {
+        id: row.id,
+        project: row.project,
+        scope: row.scope,
+        mode: row.mode,
+        name: row.name,
+        description: row.description,
+        instructions: JSON.parse(row.instructions_json),
+        capabilities: JSON.parse(row.capabilities_json),
+        permissions: JSON.parse(row.permissions_json),
+        memory: JSON.parse(row.memory_json),
+        workflows: JSON.parse(row.workflows_json),
+        skills: JSON.parse(row.skills_json),
+        adapters: JSON.parse(row.adapters_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+    if (row.parent_agent_id !== null)
+        value.parentAgentId = row.parent_agent_id;
+    return value;
+}
+function toSummary(agent) {
+    const value = {
+        id: agent.id,
+        project: agent.project,
+        scope: agent.scope,
+        mode: agent.mode,
+        name: agent.name,
+        description: agent.description,
+        capabilities: agent.capabilities,
+        createdAt: agent.createdAt,
+        updatedAt: agent.updatedAt,
+    };
+    if (agent.parentAgentId !== undefined)
+        value.parentAgentId = agent.parentAgentId;
+    return value;
+}
+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 AgentRegistryValidationError extends Error {
+}

package/dist/storage/agents/repositories/manager-profile-overlays.js

@@ -0,0 +1,90 @@
+import { randomUUID } from 'node:crypto';
+export class ManagerProfileOverlayRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    save(input) {
+        const validation = validate(input);
+        if (!validation.ok)
+            return validation;
+        try {
+            const existing = this.find(input.project, input.scope, input.managerName);
+            const id = existing?.id ?? randomUUID();
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO manager_profile_overlays(id, project, scope, manager_name, instructions, created_at, updated_at)
+        VALUES (@id, @project, @scope, @managerName, @instructions, @createdAt, @updatedAt)
+        ON CONFLICT(project, scope, manager_name) DO UPDATE SET
+          instructions=excluded.instructions,
+          updated_at=excluded.updated_at
+      `)
+                .run({
+                id,
+                project: input.project.trim(),
+                scope: input.scope,
+                managerName: input.managerName.trim(),
+                instructions: input.instructions.trim(),
+                createdAt: existing?.created_at ?? now,
+                updatedAt: now,
+            });
+            const saved = this.get(input.project, input.scope, input.managerName);
+            if (!saved.ok)
+                return saved;
+            return saved;
+        }
+        catch (cause) {
+            return fail('Failed to save manager profile overlay', cause);
+        }
+    }
+    get(project, scope, managerName) {
+        try {
+            const row = this.find(project, scope, managerName);
+            return row === undefined ? missing(`Manager profile overlay not found: ${project}/${scope}/${managerName}`) : ok(map(row));
+        }
+        catch (cause) {
+            return fail('Failed to read manager profile overlay', cause);
+        }
+    }
+    find(project, scope, managerName) {
+        return this.db.connection
+            .prepare('SELECT * FROM manager_profile_overlays WHERE project=? AND scope=? AND manager_name=?')
+            .get(project.trim(), scope, managerName.trim());
+    }
+}
+function validate(input) {
+    if (!input.project.trim())
+        return validationFailure('Project is required');
+    if (!input.managerName.trim())
+        return validationFailure('managerName is required');
+    if (!input.instructions.trim())
+        return validationFailure('instructions are required');
+    return ok(undefined);
+}
+function map(row) {
+    return {
+        id: row.id,
+        project: row.project,
+        scope: row.scope,
+        managerName: row.manager_name,
+        instructions: row.instructions,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+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 };
+}

package/dist/storage/memory/repositories/artifacts.js

@@ -0,0 +1,67 @@
+import { randomUUID } from 'node:crypto';
+export class ArtifactRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    save(input) {
+        const result = this.db.transaction(() => {
+            const existing = this.db.connection.prepare('SELECT * FROM artifacts WHERE project=@project AND topic_key=@topicKey').get(input);
+            const now = new Date().toISOString();
+            this.db.connection
+                .prepare(`INSERT INTO artifacts(id, project, topic_key, phase, content, metadata_json, observation_id, created_at, updated_at)
+        VALUES (@id, @project, @topicKey, @phase, @content, @metadataJson, @observationId, @createdAt, @updatedAt)
+        ON CONFLICT(project, topic_key) DO UPDATE SET phase=excluded.phase, content=excluded.content, metadata_json=excluded.metadata_json, observation_id=excluded.observation_id, updated_at=excluded.updated_at`)
+                .run({
+                ...input,
+                metadataJson: input.metadata === undefined ? null : JSON.stringify(input.metadata),
+                id: existing?.id ?? randomUUID(),
+                createdAt: existing?.created_at ?? now,
+                updatedAt: now,
+            });
+            const artifact = this.getByTopic(input.project, input.topicKey);
+            if (!artifact.ok)
+                throw new Error(artifact.error.message);
+            return artifact.value;
+        });
+        return result.ok ? result : fail(result.error.message, result.error.cause);
+    }
+    getByTopic(project, topicKey) {
+        try {
+            const row = this.db.connection.prepare('SELECT * FROM artifacts WHERE project=? AND topic_key=?').get(project, topicKey);
+            return row ? { ok: true, value: map(row) } : { ok: false, error: { code: 'not_found', message: `Artifact not found: ${topicKey}` } };
+        }
+        catch (cause) {
+            return fail('Failed to read artifact', cause);
+        }
+    }
+    listByTopicPrefix(project, topicPrefix) {
+        try {
+            const rows = this.db.connection
+                .prepare('SELECT * FROM artifacts WHERE project=? AND topic_key LIKE ? ORDER BY topic_key ASC')
+                .all(project, `${topicPrefix}%`);
+            return { ok: true, value: rows.map(map).filter((artifact) => artifact.topicKey.startsWith(topicPrefix)) };
+        }
+        catch (cause) {
+            return fail('Failed to list artifacts', cause);
+        }
+    }
+}
+function map(row) {
+    const artifact = {
+        id: row.id,
+        project: row.project,
+        topicKey: row.topic_key,
+        phase: row.phase,
+        content: row.content,
+        observationId: row.observation_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+    if (row.metadata_json !== null && row.metadata_json !== undefined)
+        artifact.metadata = JSON.parse(row.metadata_json);
+    return artifact;
+}
+function fail(message, cause) {
+    return { ok: false, error: { code: 'validation_failed', message, cause } };
+}