@amalgm/agents 0.1.1 → 0.1.3

package/dist/bundles/util.js

@@ -0,0 +1,56 @@
+import crypto from 'node:crypto';
+export const BUNDLE_KIND = 'amalgm.bundle';
+export const BUNDLE_SCHEMA_VERSION = 2;
+export function clean(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+export function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function uniqueStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(clean).filter(Boolean))];
+}
+export function addUnique(target, value) {
+    if (value && !target.includes(value))
+        target.push(value);
+}
+export function bundleId() {
+    return `agent-bundle-${crypto.randomUUID()}`;
+}
+export function digest(value) {
+    return crypto.createHash('sha256').update(typeof value === 'string' ? value : JSON.stringify(value))
+        .digest('hex').slice(0, 16);
+}
+export function emptyRequirements() {
+    return { runtimes: [], auth: [], secrets: [], bindings: [], systemTools: [],
+        systemActions: [], missingTools: [] };
+}
+export function mergeRequirements(target, incoming = {}) {
+    for (const key of Object.keys(target)) {
+        for (const value of incoming[key] || [])
+            addUnique(target[key], value);
+    }
+    return target;
+}
+const SECRET = /(api[_-]?key|authorization|bearer|cookie|password|passwd|secret|token|credential|private[_-]?key)/i;
+export function scrubSecrets(value, path, requires) {
+    if (Array.isArray(value))
+        return value.map((item, index) => scrubSecrets(item, `${path}[${index}]`, requires));
+    const record = object(value);
+    if (!record)
+        return value;
+    const output = {};
+    for (const [key, child] of Object.entries(record)) {
+        const childPath = path ? `${path}.${key}` : key;
+        if (SECRET.test(key))
+            addUnique(requires.secrets, childPath);
+        else
+            output[key] = scrubSecrets(child, childPath, requires);
+    }
+    return output;
+}

package/dist/bundles/validate.d.ts

@@ -0,0 +1,2 @@
+import type { AgentBundle } from './types.js';
+export declare function validateAgentBundle(input: unknown): AgentBundle;

package/dist/bundles/validate.js

@@ -0,0 +1,92 @@
+import { actionEntryId, agentEntryId, appEntryId, automationEntryId, skillFingerprint, toolEntryId } from './graph-records.js';
+import { buildBundleGraph } from './graph.js';
+import { BUNDLE_KIND, BUNDLE_SCHEMA_VERSION, clean, object } from './util.js';
+function unique(label, records, identify) {
+    const seen = new Set();
+    for (const record of records) {
+        const id = identify(record);
+        if (!id)
+            throw new Error(`${label} entries must include ids`);
+        if (seen.has(id))
+            throw new Error(`Bundle contains duplicate ${label} id: ${id}`);
+        seen.add(id);
+    }
+}
+function assertClosed(bundle) {
+    const elements = new Set();
+    for (const element of bundle.elements) {
+        if (!clean(element.id) || !clean(element.type))
+            throw new Error('bundle graph elements must include id and type');
+        if (object(element)?.data !== undefined)
+            throw new Error(`bundle graph element must not copy data: ${element.id}`);
+        if (elements.has(element.id))
+            throw new Error(`bundle graph contains duplicate element id: ${element.id}`);
+        elements.add(element.id);
+    }
+    const outgoing = new Map();
+    const edgeKeys = new Set();
+    for (const edge of bundle.edges) {
+        if (!elements.has(edge.from) || !elements.has(edge.to))
+            throw new Error('bundle graph edge references missing element');
+        const key = `${edge.from}::${edge.kind}::${edge.to}`;
+        if (edgeKeys.has(key))
+            throw new Error(`bundle graph contains duplicate edge: ${key}`);
+        edgeKeys.add(key);
+        outgoing.set(edge.from, [...(outgoing.get(edge.from) || []), edge.to]);
+    }
+    const reachable = new Set();
+    const pending = [...bundle.headIds];
+    while (pending.length) {
+        const id = pending.pop();
+        if (reachable.has(id))
+            continue;
+        reachable.add(id);
+        pending.push(...(outgoing.get(id) || []));
+    }
+    const unreachable = [...elements].filter((id) => !reachable.has(id));
+    if (unreachable.length)
+        throw new Error(`bundle graph contains unreachable elements: ${unreachable.join(', ')}`);
+}
+// Engine reference: amalgm-mcp/agent-bundles/install.js validateBundle.
+export function validateAgentBundle(input) {
+    const raw = object(input);
+    if (!raw)
+        throw new Error('bundle must be an object');
+    if (raw.kind !== BUNDLE_KIND)
+        throw new Error(`Unsupported bundle kind: ${clean(raw.kind) || 'unknown'}`);
+    if (raw.schemaVersion !== BUNDLE_SCHEMA_VERSION) {
+        throw new Error(`Unsupported bundle schema version: ${String(raw.schemaVersion || 'unknown')}`);
+    }
+    const bundle = input;
+    const arrays = ['agents', 'automations', 'apps', 'tools', 'toolActions', 'skills', 'heads'];
+    if (arrays.some((key) => !Array.isArray(bundle[key])))
+        throw new Error('bundle canonical records must be arrays');
+    if (!bundle.heads.length)
+        throw new Error('bundle must include at least one head');
+    unique('agent', bundle.agents, agentEntryId);
+    unique('automation', bundle.automations, automationEntryId);
+    unique('app', bundle.apps, appEntryId);
+    unique('tool', bundle.tools, toolEntryId);
+    unique('tool action', bundle.toolActions, actionEntryId);
+    unique('skill', bundle.skills, skillFingerprint);
+    unique('head', bundle.heads, (value) => {
+        const head = object(value);
+        return ['agent', 'automation', 'app', 'tool'].includes(clean(head?.type))
+            ? `${clean(head?.type)}:${clean(head?.id)}` : '';
+    });
+    if (bundle.requires?.missingTools?.length) {
+        throw new Error(`Bundle is missing tools: ${bundle.requires.missingTools.join(', ')}`);
+    }
+    const expected = buildBundleGraph(bundle);
+    const expectedRoot = bundle.heads.find((head) => head.type === 'agent')?.id || null;
+    if (bundle.rootAgentId !== expectedRoot) {
+        throw new Error('bundle rootAgentId does not match its canonical records and connections');
+    }
+    for (const key of ['headIds', 'elements', 'edges']) {
+        if (JSON.stringify(bundle[key]) !== JSON.stringify(expected[key])) {
+            throw new Error(`bundle ${key} does not match its canonical records and connections`);
+        }
+    }
+    assertClosed(bundle);
+    return bundle;
+}

package/dist/config/import.d.ts

@@ -0,0 +1,14 @@
+import type { Agents } from '../agents.js';
+import type { AgentRecord } from '../types.js';
+import type { AgentConfig } from './types.js';
+export declare function importAgentConfig(agents: Agents, agentId: string, options?: {
+    homeDir?: string;
+    replace?: boolean;
+}): {
+    config: AgentConfig;
+    importedAgents: {
+        created: boolean;
+        agent: AgentRecord;
+    }[];
+    sources: string[];
+};

package/dist/config/import.js

@@ -0,0 +1,59 @@
+import { AgentError } from '../errors.js';
+import { importNativeConfig } from './native.js';
+import { normalizeAgentConfig, stableConfigId } from './schema.js';
+import { configFromAgent, updateAgentConfig } from './store.js';
+function mergeById(existing, incoming) {
+    return [...new Map([...existing, ...incoming].map((item) => [item.id, item])).values()];
+}
+function mergeSubagents(existing, incoming) {
+    return [...new Map([...existing, ...incoming].map((item) => [item.agentId, item])).values()];
+}
+function importedId(parent, name) {
+    return stableConfigId('imported-agent', `${parent.id}-${name || 'subagent'}`);
+}
+function ensureImportedAgent(agents, parent, native) {
+    const id = importedId(parent, native.name);
+    const existing = agents.getAgent(id) || agents.listAgents().find((item) => item.definition.name === native.name);
+    if (existing) {
+        updateAgentConfig(agents, existing.id, {
+            instructions: native.instructions || existing.definition.instructions,
+        });
+        return { agent: agents.getAgent(existing.id), created: false };
+    }
+    const agent = agents.createAgent({
+        id, name: native.name, description: native.description,
+        driver: { ...parent.definition.driver, id: native.driverId }, model: parent.definition.model,
+        authRef: parent.definition.authRef, instructions: native.instructions,
+        resources: { files: [], skills: [], subagents: [] },
+        toolbox: { toolIds: [], actionIds: [] }, workspace: parent.definition.workspace,
+        metadata: { importedFrom: native.source },
+    });
+    updateAgentConfig(agents, agent.id, { instructions: native.instructions });
+    return { agent: agents.getAgent(agent.id), created: true };
+}
+function mergedConfig(existing, imported, subagents, replace) {
+    if (replace)
+        return normalizeAgentConfig({ ...existing, ...imported, subagents }, existing);
+    return normalizeAgentConfig({
+        ...existing,
+        instructions: existing.instructions || imported.instructions || '',
+        skills: mergeById(existing.skills, imported.skills || []),
+        hooks: mergeById(existing.hooks, imported.hooks || []),
+        subagents: mergeSubagents(existing.subagents, subagents),
+    }, existing);
+}
+// Engine reference: amalgm-mcp/agent-config/rest.js handleImportNative.
+export function importAgentConfig(agents, agentId, options = {}) {
+    const parent = agents.getAgent(agentId);
+    if (!parent)
+        throw new AgentError('not_found', `Agent not found: ${agentId}`);
+    const imported = importNativeConfig(parent.definition.driver.id, options.homeDir);
+    const importedAgents = imported.agents.map((native) => ensureImportedAgent(agents, parent, native));
+    const references = importedAgents.map(({ agent }, index) => ({
+        id: stableConfigId('subagent', agent.id), agentId: agent.id,
+        name: agent.definition.name, description: agent.definition.description, enabled: true,
+        source: imported.agents[index]?.source || { kind: 'native-import' },
+    }));
+    const config = mergedConfig(configFromAgent(parent), imported.config, references, options.replace === true);
+    return { config: updateAgentConfig(agents, agentId, config).config, importedAgents, sources: imported.sources };
+}

package/dist/config/native.d.ts

@@ -0,0 +1,2 @@
+import type { NativeConfigImport } from './types.js';
+export declare function importNativeConfig(driverId: string, homeDir?: string): NativeConfigImport;

package/dist/config/native.js

@@ -0,0 +1,179 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parseSkillFrontmatter } from '../skills/scanner.js';
+import { stableConfigId } from './schema.js';
+function readText(file, maxBytes = 128 * 1024) {
+    try {
+        const stat = fs.statSync(file);
+        return stat.isFile() && stat.size <= maxBytes ? fs.readFileSync(file, 'utf8') : '';
+    }
+    catch {
+        return '';
+    }
+}
+function readJson(file) {
+    try {
+        const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function directories(root) {
+    try {
+        return fs.readdirSync(root, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map((entry) => path.join(root, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+function markdownFiles(root) {
+    try {
+        return fs.readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+            const file = path.join(root, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.'))
+                return markdownFiles(file);
+            return entry.isFile() && entry.name.toLowerCase().endsWith('.md') ? [file] : [];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function skillsFrom(root, provider) {
+    return directories(root).flatMap((directory) => {
+        const file = path.join(directory, 'SKILL.md');
+        const content = readText(file);
+        if (!content)
+            return [];
+        const parsed = parseSkillFrontmatter(content);
+        const name = parsed.name || path.basename(directory);
+        return [{
+                id: stableConfigId('skill', `${provider}-${name}`), name,
+                description: parsed.description || '', content, enabled: true,
+                source: { kind: 'native-import', provider, path: file },
+            }];
+    });
+}
+function agentsFrom(root, provider) {
+    return markdownFiles(root).flatMap((file) => {
+        const content = readText(file);
+        if (!content)
+            return [];
+        const parsed = parseSkillFrontmatter(content);
+        const end = content.startsWith('---\n') ? content.indexOf('\n---', 4) : -1;
+        const body = end >= 0 ? content.slice(end + 4).replace(/^\r?\n/, '').trim() : content.trim();
+        return [{
+                name: parsed.name || path.basename(file, path.extname(file)),
+                description: parsed.description || '', driverId: provider, instructions: body,
+                source: { kind: 'native-import', provider, path: file },
+            }];
+    });
+}
+function appendHook(hooks, provider, sourcePath, event, value, matcher = '') {
+    const command = typeof value.command === 'string' ? value.command.trim() : '';
+    if (!command)
+        return;
+    const timeout = Number(value.timeout);
+    const phases = {
+        UserPromptSubmit: 'userSubmit', UserSubmit: 'userSubmit', Stop: 'responseComplete',
+        ResponseComplete: 'responseComplete',
+    };
+    hooks.push({
+        id: `${provider}:${sourcePath}:${event}:${hooks.length}`,
+        name: command.split(/\s+/).slice(0, 3).join(' '), enabled: true,
+        event, phase: phases[event] || event, matcher, type: 'command', command,
+        ...(Number.isFinite(timeout) && timeout > 0 ? { timeout } : {}),
+        ...(typeof value.statusMessage === 'string' && value.statusMessage.trim()
+            ? { statusMessage: value.statusMessage.trim() } : {}),
+        source: { kind: 'native-import', provider, path: sourcePath },
+    });
+}
+function extractHooks(value, hooks, provider, sourcePath, event, matcher = '') {
+    if (typeof value === 'string') {
+        appendHook(hooks, provider, sourcePath, event, { command: value }, matcher);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item) => extractHooks(item, hooks, provider, sourcePath, event, matcher));
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    const object = value;
+    const nextEvent = typeof object.event === 'string' ? object.event : event;
+    const nextMatcher = typeof object.matcher === 'string' ? object.matcher : matcher;
+    appendHook(hooks, provider, sourcePath, nextEvent, object, nextMatcher);
+    if (Array.isArray(object.hooks)) {
+        extractHooks(object.hooks, hooks, provider, sourcePath, nextEvent, nextMatcher);
+    }
+}
+function hooksFrom(files, provider) {
+    const hooks = [];
+    for (const file of files) {
+        const data = readJson(file);
+        const raw = data?.hooks ?? data;
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            continue;
+        for (const [event, value] of Object.entries(raw)) {
+            extractHooks(value, hooks, provider, file, event);
+        }
+    }
+    return hooks;
+}
+// Engine references: agent-config/importers/* and agents/hooks.js. Only
+// instructions, skills, command hooks, and agent markdown cross this boundary.
+export function importNativeConfig(driverId, homeDir = os.homedir()) {
+    if (driverId === 'codex') {
+        const root = path.join(homeDir, '.codex');
+        const instructions = readText(path.join(root, 'AGENTS.md'));
+        const hooksFile = path.join(root, 'hooks.json');
+        const skills = skillsFrom(path.join(root, 'skills'), driverId);
+        const hooks = hooksFrom([hooksFile], driverId);
+        return {
+            config: { ...(instructions ? { instructions } : {}), ...(skills.length ? { skills } : {}),
+                ...(hooks.length ? { hooks } : {}) },
+            agents: [], sources: [path.join(root, 'AGENTS.md'), path.join(root, 'skills'), hooksFile],
+        };
+    }
+    if (driverId === 'claude_code') {
+        const root = path.join(homeDir, '.claude');
+        const settings = ['settings.json', 'settings.local.json'].map((name) => path.join(root, name));
+        const instructions = readText(path.join(root, 'CLAUDE.md')) || readText(path.join(homeDir, 'CLAUDE.md'));
+        const configRoot = path.join(homeDir, '.config', 'claude');
+        const skills = [...skillsFrom(path.join(root, 'skills'), driverId),
+            ...skillsFrom(path.join(configRoot, 'skills'), driverId)];
+        const hooks = hooksFrom([...settings, path.join(homeDir, '.claude.json')], driverId);
+        const agents = [...agentsFrom(path.join(root, 'agents'), driverId),
+            ...agentsFrom(path.join(configRoot, 'agents'), driverId)];
+        return {
+            config: { ...(instructions ? { instructions } : {}), ...(skills.length ? { skills } : {}),
+                ...(hooks.length ? { hooks } : {}) },
+            agents,
+            sources: [path.join(root, 'CLAUDE.md'), path.join(root, 'skills'), path.join(root, 'agents'), ...settings],
+        };
+    }
+    if (driverId === 'opencode') {
+        const config = path.join(homeDir, '.config', 'opencode');
+        const dot = path.join(homeDir, '.opencode');
+        const data = readJson(path.join(config, 'opencode.json')) || readJson(path.join(config, 'config.json'))
+            || readJson(path.join(dot, 'opencode.json')) || {};
+        const instructions = ['instructions', 'systemPrompt', 'prompt']
+            .map((key) => data[key]).find((value) => typeof value === 'string');
+        const instructionText = instructions || readText(path.join(dot, 'AGENTS.md'));
+        const skills = [...skillsFrom(path.join(config, 'skills'), driverId),
+            ...skillsFrom(path.join(dot, 'skills'), driverId)];
+        return {
+            config: { ...(instructionText ? { instructions: instructionText } : {}),
+                ...(skills.length ? { skills } : {}) },
+            agents: [...agentsFrom(path.join(config, 'agents'), driverId), ...agentsFrom(path.join(dot, 'agents'), driverId)],
+            sources: [path.join(config, 'opencode.json'), path.join(config, 'skills'), path.join(config, 'agents'),
+                path.join(dot, 'AGENTS.md'), path.join(dot, 'skills'), path.join(dot, 'agents')],
+        };
+    }
+    return { config: {}, agents: [], sources: [] };
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig, AgentConfigInput } from './types.js';
+export declare function stableConfigId(prefix: string, seed: string): string;
+export declare function normalizeAgentConfig(input?: AgentConfigInput, fallback?: AgentConfigInput): AgentConfig;

package/dist/config/schema.js

@@ -0,0 +1,135 @@
+import crypto from 'node:crypto';
+import { isObject } from '../json.js';
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function clone(value, fallback) {
+    return isObject(value) ? JSON.parse(JSON.stringify(value)) : fallback;
+}
+function uniqueStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(text).filter(Boolean))];
+}
+export function stableConfigId(prefix, seed) {
+    const clean = text(seed).toLowerCase().replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '').slice(0, 80);
+    return clean ? `${prefix}-${clean}` : `${prefix}-${crypto.randomUUID()}`;
+}
+function skill(value, index) {
+    if (typeof value === 'string') {
+        const name = text(value);
+        return name ? {
+            id: stableConfigId('skill', name), name, description: '', content: '', enabled: true,
+            source: { kind: 'amalgm' },
+        } : null;
+    }
+    if (!isObject(value))
+        return null;
+    const content = typeof value.content === 'string' ? value.content : '';
+    const name = text(value.name || value.id) || `Skill ${index + 1}`;
+    if (!name && !content)
+        return null;
+    return {
+        id: text(value.id) || stableConfigId('skill', name || content.slice(0, 80)),
+        name, description: typeof value.description === 'string' ? value.description : '', content,
+        enabled: value.enabled !== false, source: clone(value.source, { kind: 'amalgm' }),
+    };
+}
+function skills(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byId = new Map();
+    value.forEach((item, index) => {
+        const normalized = skill(item, index);
+        if (normalized)
+            byId.set(normalized.id, normalized);
+    });
+    return [...byId.values()];
+}
+function hook(value, index) {
+    if (!isObject(value))
+        return null;
+    const command = text(value.command);
+    const type = text(value.type) || (command ? 'command' : 'native');
+    if (type === 'command' && !command)
+        return null;
+    const event = text(value.event || value.phase) || 'UserPromptSubmit';
+    const name = text(value.name || value.label) || command.split(/\s+/).slice(0, 3).join(' ') || event;
+    const timeout = Number(value.timeout);
+    return {
+        id: text(value.id) || stableConfigId('hook', `${event}-${name}-${index}`),
+        name, enabled: value.enabled !== false, event, phase: text(value.phase) || event,
+        matcher: typeof value.matcher === 'string' ? value.matcher : '', type,
+        ...(command ? { command } : {}),
+        ...(Number.isFinite(timeout) && timeout > 0 ? { timeout } : {}),
+        ...(text(value.statusMessage) ? { statusMessage: text(value.statusMessage) } : {}),
+        source: clone(value.source, {
+            kind: value.source === 'native' ? 'native-import' : 'amalgm',
+            ...(text(value.harnessId) ? { harnessId: text(value.harnessId) } : {}),
+            ...(text(value.sourcePath) ? { path: text(value.sourcePath) } : {}),
+        }),
+    };
+}
+function hooks(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byId = new Map();
+    value.forEach((item, index) => {
+        const normalized = hook(item, index);
+        if (normalized)
+            byId.set(normalized.id, normalized);
+    });
+    return [...byId.values()];
+}
+function subagent(value, index) {
+    const raw = typeof value === 'string' ? { agentId: value } : value;
+    if (!isObject(raw))
+        return null;
+    const agentId = text(raw.agentId || raw.agent_id || raw.id);
+    if (!agentId)
+        return null;
+    return {
+        id: text(raw.id) || stableConfigId('subagent', `${agentId}-${index}`), agentId,
+        name: text(raw.name), description: typeof raw.description === 'string' ? raw.description : '',
+        enabled: raw.enabled !== false, source: clone(raw.source, { kind: 'amalgm' }),
+    };
+}
+function subagents(value) {
+    if (!Array.isArray(value))
+        return [];
+    const byAgent = new Map();
+    value.forEach((item, index) => {
+        const normalized = subagent(item, index);
+        if (normalized)
+            byAgent.set(normalized.agentId, normalized);
+    });
+    return [...byAgent.values()];
+}
+function loadout(value, fallback) {
+    const raw = isObject(value) ? value : {};
+    const prior = isObject(fallback) ? fallback : {};
+    const aliases = (source) => source.toolIds || source.selectedToolIds
+        || source.selected || source.tools;
+    const explicit = ['toolIds', 'selectedToolIds', 'selected', 'tools']
+        .some((key) => Object.hasOwn(raw, key));
+    return { toolIds: uniqueStrings(explicit ? aliases(raw) : aliases(prior)) };
+}
+// Engine reference: amalgm-mcp/agent-config/schema.js.
+export function normalizeAgentConfig(input = {}, fallback = {}) {
+    const raw = isObject(input) ? input : {};
+    const prior = isObject(fallback) ? fallback : {};
+    const agentId = text(raw.agentId || raw.agent_id || prior.agentId);
+    const instructions = raw.instructions ?? raw.systemPrompt;
+    const instructionText = isObject(instructions) && typeof instructions.text === 'string'
+        ? instructions.text : instructions;
+    return {
+        version: 1, ...(agentId ? { agentId } : {}), runtimeHomeLayout: 'per-agent',
+        instructions: typeof instructionText === 'string'
+            ? instructionText : typeof prior.instructions === 'string' ? prior.instructions : '',
+        skills: skills(raw.skills ?? prior.skills ?? []),
+        loadout: loadout(raw.loadout ?? raw.toolset ?? raw.tools, prior.loadout ?? prior.tools),
+        hooks: hooks(raw.hooks ?? prior.hooks ?? []),
+        subagents: subagents(raw.subagents ?? prior.subagents ?? []),
+    };
+}

package/dist/config/store.d.ts

@@ -0,0 +1,9 @@
+import type { Agents } from '../agents.js';
+import type { AgentRecord } from '../types.js';
+import type { AgentConfig, AgentConfigInput } from './types.js';
+export declare function configFromAgent(agent: AgentRecord): AgentConfig;
+export declare function listAgentConfigs(agents: Agents): AgentConfig[];
+export declare function updateAgentConfig(agents: Agents, agentId: string, patch: AgentConfigInput): {
+    agent: AgentRecord;
+    config: AgentConfig;
+};

package/dist/config/store.js

@@ -0,0 +1,56 @@
+import { AgentError } from '../errors.js';
+import { isObject } from '../json.js';
+import { normalizeAgentConfig } from './schema.js';
+const METADATA_KEY = 'agentConfig';
+function configDocument(agent) {
+    const value = agent.definition.metadata[METADATA_KEY];
+    return isObject(value) ? value : {};
+}
+function same(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+// Engine reference: amalgm-mcp/agent-config/store.js. The immutable Agent
+// revision is the store here; no second agent_configs database is introduced.
+export function configFromAgent(agent) {
+    const stored = normalizeAgentConfig(configDocument(agent), {
+        agentId: agent.id,
+        instructions: agent.definition.instructions,
+        skills: agent.definition.resources.skills,
+        loadout: { toolIds: agent.definition.toolbox.toolIds },
+        subagents: agent.definition.resources.subagents,
+    });
+    const skillRefs = stored.skills.filter((item) => item.enabled).map((item) => item.name || item.id);
+    const subagentRefs = stored.subagents.filter((item) => item.enabled).map((item) => item.agentId);
+    return normalizeAgentConfig({
+        ...stored,
+        agentId: agent.id,
+        instructions: stored.instructions.trim() === agent.definition.instructions
+            ? stored.instructions : agent.definition.instructions,
+        skills: same(skillRefs, agent.definition.resources.skills)
+            ? stored.skills : agent.definition.resources.skills,
+        loadout: { toolIds: agent.definition.toolbox.toolIds },
+        subagents: same(subagentRefs, agent.definition.resources.subagents)
+            ? stored.subagents : agent.definition.resources.subagents,
+    }, stored);
+}
+export function listAgentConfigs(agents) {
+    return agents.listAgents().map(configFromAgent);
+}
+export function updateAgentConfig(agents, agentId, patch) {
+    const current = agents.getAgent(agentId);
+    if (!current)
+        throw new AgentError('not_found', `Agent not found: ${agentId}`);
+    const existing = configFromAgent(current);
+    const config = normalizeAgentConfig({ ...existing, ...patch, agentId }, existing);
+    const metadata = { ...current.definition.metadata, [METADATA_KEY]: config };
+    const projected = {
+        instructions: config.instructions,
+        resources: {
+            skills: config.skills.filter((item) => item.enabled).map((item) => item.name || item.id),
+            subagents: config.subagents.filter((item) => item.enabled).map((item) => item.agentId),
+        },
+        toolbox: { toolIds: config.loadout.toolIds },
+        metadata,
+    };
+    return { agent: agents.updateAgent(agentId, projected), config };
+}

package/dist/config/types.d.ts

@@ -0,0 +1,55 @@
+import type { JsonObject } from '../types.js';
+export interface ConfigSkill {
+    id: string;
+    name: string;
+    description: string;
+    content: string;
+    enabled: boolean;
+    source: JsonObject;
+}
+export interface ConfigHook {
+    id: string;
+    name: string;
+    enabled: boolean;
+    event: string;
+    phase: string;
+    matcher: string;
+    type: string;
+    command?: string;
+    timeout?: number;
+    statusMessage?: string;
+    source: JsonObject;
+}
+export interface ConfigSubagent {
+    id: string;
+    agentId: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    source: JsonObject;
+}
+export interface AgentConfig {
+    version: 1;
+    agentId?: string;
+    runtimeHomeLayout: 'per-agent';
+    instructions: string;
+    skills: ConfigSkill[];
+    loadout: {
+        toolIds: string[];
+    };
+    hooks: ConfigHook[];
+    subagents: ConfigSubagent[];
+}
+export interface NativeAgent {
+    name: string;
+    description: string;
+    driverId: string;
+    instructions: string;
+    source: JsonObject;
+}
+export interface NativeConfigImport {
+    config: Partial<AgentConfig>;
+    agents: NativeAgent[];
+    sources: string[];
+}
+export type AgentConfigInput = AgentConfig | Record<string, unknown>;