vgxness 1.20.4 → 1.20.6

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

@@ -1,90 +1 @@
-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 };
-}
+export * from '../../storage/agents/repositories/manager-profile-overlays.js';

package/dist/agents/schema.js

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

package/dist/application/agents/agent-activation-service.js

@@ -0,0 +1,261 @@
+import { responseByteAccounting, summarizePayloadContent } from '../../payload/payload-summary.js';
+import { resolveAgentProfileModel } from './profile-model-routing.js';
+const defaultAgentName = 'vgxness-manager';
+const provider = 'opencode';
+const nextSafeAction = 'review_provider_payload_and_choose_manual_handoff';
+const safety = { executesProvider: false, writesProviderConfig: false, backgroundWorker: false, autonomy: false };
+export class AgentActivationService {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    activate(input) {
+        const validated = validateActivationInput(input);
+        if (!validated.ok)
+            return validated;
+        const agent = this.resolveAgent(validated.value);
+        if (!agent.ok)
+            return agent;
+        if (agent.value.mode !== 'agent')
+            return validationFailure('Agent activation requires a top-level agent');
+        const selection = resolveAgentProfileModel({
+            agent: agent.value,
+            ...(validated.value.providerAdapter === undefined ? {} : { providerAdapter: validated.value.providerAdapter }),
+        });
+        if (!selection.ok)
+            return selection;
+        if (selection.value.providerAdapter !== provider)
+            return validationFailure(`Provider adapter is not supported for activation: ${selection.value.providerAdapter}`);
+        const run = this.dependencies.runs.createRun({
+            project: validated.value.project,
+            userIntent: validated.value.userIntent,
+            workflow: validated.value.workflow,
+            phase: validated.value.phase,
+            selectedAgentId: agent.value.id,
+            providerAdapter: selection.value.providerAdapter,
+            model: selection.value.model,
+        });
+        if (!run.ok)
+            return run;
+        const payloadMode = resolvePayloadMode(validated.value);
+        const payload = this.dependencies.opencodeManagerPayload.build(toPayloadInput(validated.value, agent.value.id, payloadMode));
+        if (!payload.ok)
+            return this.failAfterRun(run.value.id, payload.error.code, payload.error.message);
+        const verboseEnvelopeWithoutRun = {
+            version: 1,
+            agent: { id: agent.value.id, name: agent.value.name, scope: agent.value.scope, mode: 'agent' },
+            provider,
+            modelSelection: selection.value,
+            providerPayload: payload.value,
+            ...(payload.value.skillPayload !== undefined ? { skillsContext: payload.value.skillPayload } : {}),
+            nextSafeAction,
+            safety,
+            warnings: [
+                'Agent activation prepared a provider-ready payload but does not execute providers.',
+                'No provider configuration, background worker, autonomous step, or secrets expansion was performed.',
+                ...selection.value.warnings,
+                ...payload.value.warnings,
+            ],
+        };
+        const envelopeWithoutRun = payloadMode === 'compact' ? compactActivationEnvelope(verboseEnvelopeWithoutRun, validated.value) : verboseEnvelopeWithoutRun;
+        const checkpoint = this.dependencies.runs.appendCheckpoint({
+            runId: run.value.id,
+            label: 'agent-activation-initial',
+            state: toJson(checkpointState(envelopeWithoutRun, run.value.id, payloadMode)),
+        });
+        if (!checkpoint.ok)
+            return this.failAfterRun(run.value.id, checkpoint.error.code, checkpoint.error.message);
+        const event = this.dependencies.runs.appendEvent({
+            runId: run.value.id,
+            kind: 'timeline',
+            title: 'Agent activation prepared',
+            payload: toJson({
+                agent: envelopeWithoutRun.agent,
+                provider,
+                modelSelection: selection.value,
+                nextSafeAction,
+                safety,
+                checkpointId: checkpoint.value.id,
+            }),
+            relatedType: 'run-checkpoint',
+            relatedId: checkpoint.value.id,
+        });
+        if (!event.ok)
+            return this.failAfterRun(run.value.id, event.error.code, event.error.message);
+        return ok({ ...envelopeWithoutRun, run: { id: run.value.id, status: 'created', checkpointId: checkpoint.value.id } });
+    }
+    resolveAgent(input) {
+        if (input.agentId !== undefined)
+            return this.dependencies.agents.getAgent(input.agentId);
+        if (this.dependencies.managerProfiles !== undefined) {
+            const effective = this.dependencies.managerProfiles.resolveEffectiveManager({
+                project: input.project,
+                scope: input.scope,
+                managerName: defaultAgentName,
+            });
+            return effective.ok ? ok(effective.value.manager) : effective;
+        }
+        return this.dependencies.agents.getAgentByName(input.project, input.scope, defaultAgentName);
+    }
+    failAfterRun(runId, code, message) {
+        const nestedFailures = [];
+        const eventResult = this.dependencies.runs.appendEvent({
+            runId,
+            kind: 'timeline',
+            title: 'Agent activation failed',
+            payload: toJson({ error: { code: String(code), message }, nextSafeActionReturned: false }),
+        });
+        if (!eventResult.ok) {
+            nestedFailures.push({ step: 'append-event', code: String(eventResult.error.code), message: eventResult.error.message });
+        }
+        const finalStatusResult = this.dependencies.runs.updateFinalStatus({ runId, status: 'failed', outcome: 'failure', outcomeReason: message });
+        if (!finalStatusResult.ok) {
+            nestedFailures.push({ step: 'update-final-status', code: String(finalStatusResult.error.code), message: finalStatusResult.error.message });
+        }
+        return nestedFailures.length === 0 ? { ok: false, error: { code, message } } : { ok: false, error: { code, message, cause: { nestedFailures } } };
+    }
+}
+function validateActivationInput(input) {
+    if (input.project.trim().length === 0)
+        return validationFailure('Project is required');
+    if (input.userIntent.trim().length === 0)
+        return validationFailure('userIntent is required');
+    if (input.agentId !== undefined && input.agentId.trim().length === 0)
+        return validationFailure('agentId must not be empty');
+    if (input.payloadMode !== undefined && input.payloadMode !== 'compact' && input.payloadMode !== 'verbose')
+        return validationFailure('payloadMode must be compact or verbose');
+    const validated = {
+        project: input.project.trim(),
+        scope: input.scope ?? 'project',
+        userIntent: input.userIntent.trim(),
+        workflow: input.workflow?.trim() || 'agent-activation',
+        phase: input.phase?.trim() || 'activation',
+    };
+    if (input.agentId !== undefined)
+        validated.agentId = input.agentId.trim();
+    if (input.workspaceRoot !== undefined)
+        validated.workspaceRoot = input.workspaceRoot;
+    if (input.maxSourceBytes !== undefined)
+        validated.maxSourceBytes = input.maxSourceBytes;
+    if (input.providerAdapter !== undefined) {
+        if (input.providerAdapter.trim().length === 0)
+            return validationFailure('providerAdapter must not be empty');
+        validated.providerAdapter = input.providerAdapter.trim();
+    }
+    if (input.payloadMode !== undefined)
+        validated.payloadMode = input.payloadMode;
+    return ok(validated);
+}
+function resolvePayloadMode(input) {
+    return input.payloadMode ?? 'compact';
+}
+function toPayloadInput(input, agentId, payloadMode) {
+    const payload = { project: input.project, scope: input.scope };
+    if (input.agentId !== undefined)
+        payload.agentId = agentId;
+    else
+        payload.useManagerOverlay = true;
+    if (input.workspaceRoot !== undefined)
+        payload.workspaceRoot = input.workspaceRoot;
+    if (input.maxSourceBytes !== undefined)
+        payload.maxSourceBytes = input.maxSourceBytes;
+    payload.payloadMode = payloadMode;
+    return payload;
+}
+function checkpointState(envelopeWithoutRun, runId, mode) {
+    const base = { ...envelopeWithoutRun, run: { id: runId, status: 'created', checkpointId: null } };
+    if (mode === 'verbose')
+        return toJson(base);
+    return toJson({
+        version: base.version,
+        run: base.run,
+        agent: base.agent,
+        provider: base.provider,
+        modelSelection: base.modelSelection,
+        providerPayload: {
+            version: base.providerPayload.version,
+            provider: base.providerPayload.provider,
+            payloadMode: base.providerPayload.payloadMode,
+            selection: base.providerPayload.selection,
+            providerArtifacts: base.providerPayload.providerArtifacts,
+            skillDiagnostics: base.providerPayload.skillDiagnostics,
+            safety: base.providerPayload.safety,
+            warnings: base.providerPayload.warnings,
+        },
+        skillsContext: base.skillsContext === undefined
+            ? undefined
+            : {
+                version: base.skillsContext.version,
+                providerAgnostic: base.skillsContext.providerAgnostic,
+                context: base.skillsContext.context,
+                itemCount: base.skillsContext.items.length,
+                skipped: base.skillsContext.skipped,
+                skillDiagnostics: base.skillsContext.skillDiagnostics,
+                warnings: base.skillsContext.warnings,
+            },
+        nextSafeAction: base.nextSafeAction,
+        safety: base.safety,
+        warnings: base.warnings,
+    });
+}
+function compactActivationEnvelope(verbose, input) {
+    const compactProviderPayload = {
+        version: verbose.providerPayload.version,
+        provider: verbose.providerPayload.provider,
+        payloadMode: 'compact',
+        installable: verbose.providerPayload.installable,
+        selection: verbose.providerPayload.selection,
+        providerArtifacts: verbose.providerPayload.providerArtifacts,
+        ...(verbose.providerPayload.skillDiagnostics === undefined ? {} : { skillDiagnostics: verbose.providerPayload.skillDiagnostics }),
+        safety: verbose.providerPayload.safety,
+        warnings: verbose.providerPayload.warnings,
+    };
+    const fullRetrieval = {
+        tool: 'vgxness_agent_activate',
+        payloadMode: 'verbose',
+        input: {
+            project: input.project,
+            scope: input.scope,
+            agentId: verbose.agent.id,
+            userIntent: input.userIntent,
+            workflow: input.workflow,
+            phase: input.phase,
+        },
+    };
+    const omittedSections = [];
+    if (verbose.providerPayload.skillPayload !== undefined)
+        omittedSections.push(omittedSection('providerPayload.skillPayload', 'Duplicate of skillsContext; omitted from compact activation response.', fullRetrieval, verbose.providerPayload.skillPayload));
+    if (verbose.skillsContext !== undefined)
+        omittedSections.push(omittedSection('skillsContext', 'Skill details remain durably retrievable through verbose activation or skill payload calls.', fullRetrieval, verbose.skillsContext));
+    const compact = {
+        version: verbose.version,
+        agent: verbose.agent,
+        provider: verbose.provider,
+        modelSelection: verbose.modelSelection,
+        providerPayload: compactProviderPayload,
+        omittedSections,
+        governanceConstraints: [
+            'Activation is preview-only and does not execute providers.',
+            'No provider configuration, background worker, autonomous step, or secrets expansion is performed.',
+            'Request payloadMode=verbose when full provider payload or skills context is needed.',
+        ],
+        nextSafeAction: verbose.nextSafeAction,
+        safety: verbose.safety,
+        warnings: verbose.warnings,
+    };
+    compact.responseByteAccounting = responseByteAccounting(verbose, compact);
+    return compact;
+}
+function omittedSection(path, reason, retrieval, value) {
+    const summary = summarizePayloadContent(JSON.stringify(value));
+    return { path, reason, hash: summary.contentHash, bytes: summary.contentBytes, retrieval };
+}
+function toJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function validationFailure(message) {
+    return { ok: false, error: { code: 'validation_failed', message } };
+}

package/dist/application/agents/agent-lookup-contexts.js

@@ -0,0 +1,28 @@
+export const GLOBAL_PERSONAL_AGENTS_PROJECT = '__personal__';
+export const GLOBAL_VGXNESS_AGENTS_PROJECT = '__vgxness__';
+export const LEGACY_VGXNESS_AGENTS_PROJECT = 'vgxness';
+export const agentLookupContexts = (project, scope) => {
+    const contexts = [{ project, scope }];
+    if (scope !== 'personal')
+        contexts.push({ project, scope: 'personal' });
+    if (project !== GLOBAL_PERSONAL_AGENTS_PROJECT)
+        contexts.push({ project: GLOBAL_PERSONAL_AGENTS_PROJECT, scope: 'personal' });
+    if (project !== GLOBAL_VGXNESS_AGENTS_PROJECT)
+        contexts.push({ project: GLOBAL_VGXNESS_AGENTS_PROJECT, scope: 'project' });
+    if (project !== LEGACY_VGXNESS_AGENTS_PROJECT)
+        contexts.push({ project: LEGACY_VGXNESS_AGENTS_PROJECT, scope: 'project' });
+    return dedupeContexts(contexts);
+};
+export const dedupeAgentLookupContexts = (contexts) => {
+    return dedupeContexts(contexts);
+};
+function dedupeContexts(contexts) {
+    const seen = new Set();
+    return contexts.filter((context) => {
+        const key = `${context.project}:${context.scope}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/application/agents/agent-registry-service.js

@@ -0,0 +1,81 @@
+import { AgentRepository } from '../../storage/agents/repositories/agents.js';
+import { agentLookupContexts } from './agent-lookup-contexts.js';
+import { AgentResolver } from './agent-resolver.js';
+export class AgentRegistryService {
+    database;
+    agents;
+    constructor(database) {
+        this.database = database;
+        this.agents = new AgentRepository(database);
+    }
+    registerAgent(input) {
+        return this.agents.register({ ...input, mode: 'agent' });
+    }
+    registerSubagent(input) {
+        return this.agents.register({ ...input, mode: 'subagent' });
+    }
+    getAgent(id) {
+        return this.agents.getById(id);
+    }
+    getAgentByName(project, scope, name) {
+        return this.agents.getByName(project, scope, name);
+    }
+    listAgents(filters = {}) {
+        return this.agents.list(filters);
+    }
+    listSubagents(parentAgentId) {
+        return this.agents.list({ mode: 'subagent', parentAgentId });
+    }
+    resolveAgents(input) {
+        return new AgentResolver(() => this.listAgentDefinitions(input)).resolve(input);
+    }
+    close() {
+        this.database.close();
+    }
+    listAgentDefinitions(input) {
+        if (input.project !== undefined)
+            return this.listAgentDefinitionsForContexts(input);
+        const filters = {};
+        if (input.scope !== undefined)
+            filters.scope = input.scope;
+        if (input.mode !== undefined)
+            filters.mode = input.mode;
+        const summaries = this.agents.list(filters);
+        if (!summaries.ok)
+            return summaries;
+        const definitions = [];
+        for (const summary of summaries.value) {
+            const agent = this.agents.getById(summary.id);
+            if (!agent.ok)
+                return agent;
+            definitions.push(agent.value);
+        }
+        return { ok: true, value: definitions };
+    }
+    listAgentDefinitionsForContexts(input) {
+        const project = input.project;
+        if (project === undefined)
+            return { ok: true, value: [] };
+        const summariesByName = new Map();
+        for (const context of agentLookupContexts(project, input.scope ?? 'project')) {
+            const filters = { project: context.project, scope: context.scope };
+            if (input.mode !== undefined)
+                filters.mode = input.mode;
+            const summaries = this.agents.list(filters);
+            if (!summaries.ok)
+                return summaries;
+            for (const summary of summaries.value) {
+                if (!summariesByName.has(summary.name))
+                    summariesByName.set(summary.name, summary);
+            }
+        }
+        const definitions = [];
+        for (const summary of summariesByName.values()) {
+            const agent = this.agents.getById(summary.id);
+            if (!agent.ok)
+                return agent;
+            definitions.push(agent.value);
+        }
+        return { ok: true, value: definitions };
+    }
+}