agentic-workflow-manager 3.0.1 → 3.2.0

package/dist/tests/commands/init.test.js

@@ -72,12 +72,21 @@ describe('runInit', () => {
     });
     it('returns exit 1 on a bare HOME and never prompts with --yes (cache stubbed)', async () => {
         const { runInit } = require('../../src/commands/init');
-        const code = await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { } } });
+        const code = await runInit({
+            cwd: tmpHome,
+            yes: true,
+            actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) },
+        });
         expect(code).toBe(1); // cache/hook/devCore siguen ausentes (syncCache no-op) → degradado
     });
     it('--json emits a parseable InitOutcome', async () => {
         const { runInit } = require('../../src/commands/init');
-        const code = await runInit({ cwd: tmpHome, yes: true, json: true, actions: { syncCache: async () => { } } });
+        const code = await runInit({
+            cwd: tmpHome,
+            yes: true,
+            json: true,
+            actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) },
+        });
         const written = writeSpy.mock.calls.map((c) => c[0]).join('');
         const parsed = JSON.parse(written);
         expect(Array.isArray(parsed.steps)).toBe(true);
@@ -85,23 +94,201 @@ describe('runInit', () => {
         expect(code).toBe(1);
     });
     const prefsFile = () => path_1.default.join(process.env.AWM_HOME, 'preferences.json');
-    const readAgent = () => JSON.parse(fs_1.default.readFileSync(prefsFile(), 'utf-8')).defaultAgent;
+    const readPreferences = () => JSON.parse(fs_1.default.readFileSync(prefsFile(), 'utf-8'));
+    const readAgent = () => readPreferences().defaultAgent;
+    const readPrefs = () => readPreferences();
+    function writePrefs(prefs) {
+        const { savePreferences } = require('../../src/utils/config');
+        savePreferences(prefs);
+    }
+    /**
+     * Full no-op InitActions stub set — every member records its own token
+     * onto `calls` (in invocation order) and returns a benign, type-shaped
+     * value so a whole `runInitSteps` pass can complete without touching real
+     * registry content. Used both to keep the "does the pipeline actually
+     * succeed" tests independent of real registry content, and to observe
+     * call order (install-hook / install-bundle) relative to the gate/backup/
+     * save-preferences sequence.
+     */
+    function fakeActions(calls) {
+        return {
+            syncCache: async () => { calls.push('syncCache'); },
+            installHook: () => { calls.push('install-hook'); return { status: 'installed' }; },
+            installBundle: () => { calls.push('install-bundle'); return { installed: [], skipped: [] }; },
+            syncProfile: () => { calls.push('syncProfile'); return { installed: [], skipped: [], extensions: [] }; },
+            initSensors: () => { calls.push('initSensors'); return { detection: { pack: 'generic' } }; },
+            addExtension: () => { calls.push('addExtension'); },
+            ensureProfile: () => { calls.push('ensureProfile'); },
+            gatherProject: () => { calls.push('gatherProject'); return null; },
+            contextStatus: () => { calls.push('contextStatus'); return 'absent'; },
+            installContext: () => { calls.push('installContext'); },
+            repairGlobalSkills: () => { calls.push('repairGlobalSkills'); return { relinked: [], pruned: [], failed: [] }; },
+            injectProjectConstitution: () => { calls.push('injectProjectConstitution'); return 'injected'; },
+        };
+    }
+    function codexInitOptions(calls = []) {
+        return {
+            cwd: tmpHome,
+            yes: true,
+            agent: 'codex',
+            assertProviderSupported: () => ({ provider: 'codex', version: '0.150.0' }),
+            actions: fakeActions(calls),
+        };
+    }
+    /** Cheap recursive content snapshot for "did this subtree change at all" assertions. */
+    function snapshotTree(dir) {
+        if (!fs_1.default.existsSync(dir))
+            return null;
+        const walk = (p) => {
+            const st = fs_1.default.lstatSync(p);
+            if (st.isSymbolicLink())
+                return { type: 'symlink', target: fs_1.default.readlinkSync(p) };
+            if (st.isDirectory()) {
+                const entries = fs_1.default.readdirSync(p).sort();
+                return { type: 'dir', entries: Object.fromEntries(entries.map((e) => [e, walk(path_1.default.join(p, e))])) };
+            }
+            return { type: 'file', content: fs_1.default.readFileSync(p, 'utf8') };
+        };
+        return walk(dir);
+    }
     it('#7: first init (no -a) persists claude-code as the default agent', async () => {
         const { runInit } = require('../../src/commands/init');
         expect(fs_1.default.existsSync(prefsFile())).toBe(false);
-        await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { } } });
+        await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) } });
         expect(readAgent()).toBe('claude-code');
     });
     it('#7: init -a opencode persists the explicit agent', async () => {
         const { runInit } = require('../../src/commands/init');
-        await runInit({ cwd: tmpHome, yes: true, agent: 'opencode', actions: { syncCache: async () => { } } });
+        const code = await runInit({
+            cwd: tmpHome,
+            yes: true,
+            agent: 'opencode',
+            actions: fakeActions([]),
+        });
+        expect(code).toBeLessThanOrEqual(1);
         expect(readAgent()).toBe('opencode');
+        expect(readPreferences().enabledAgents).toContain('opencode');
     });
     it('#7: re-init without -a does NOT clobber an existing explicit preference', async () => {
-        const { savePreferences } = require('../../src/utils/config');
-        savePreferences({ defaultAgent: 'opencode', installMethod: 'symlink', defaultScope: 'local' });
+        writePrefs({
+            defaultAgent: 'opencode',
+            enabledAgents: ['opencode'],
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        });
         const { runInit } = require('../../src/commands/init');
-        await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { } } });
+        await runInit({ cwd: tmpHome, yes: true, actions: { syncCache: async () => { }, installHook: () => ({ status: 'installed' }) } });
         expect(readAgent()).toBe('opencode');
     });
+    it('enabling a new default preserves every previously enabled agent', async () => {
+        writePrefs({
+            defaultAgent: 'claude-code',
+            enabledAgents: ['claude-code', 'codex'],
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        });
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({
+            cwd: tmpHome,
+            yes: true,
+            agent: 'opencode',
+            actions: fakeActions([]),
+        });
+        expect(code).toBeLessThanOrEqual(1);
+        expect(readPreferences().enabledAgents)
+            .toEqual(['claude-code', 'codex', 'opencode']);
+    });
+    // -----------------------------------------------------------------------
+    // Step 1 — gate ordering, backup/rollback atomicity, Codex/Claude coexistence
+    // -----------------------------------------------------------------------
+    it('gates Codex before preferences or provider writes', async () => {
+        const calls = [];
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({
+            cwd: tmpHome,
+            agent: 'codex',
+            yes: true,
+            actions: fakeActions(calls),
+            assertProviderSupported: () => {
+                calls.push('version-gate');
+                throw new Error('requires Codex >= 0.145.0');
+            },
+        });
+        expect(code).toBe(2);
+        expect(calls).toEqual(['version-gate']); // verifies R2
+        expect(fs_1.default.existsSync(prefsFile())).toBe(false);
+    });
+    it('enables Codex without changing the existing default or Claude files', async () => {
+        writePrefs({
+            defaultAgent: 'claude-code',
+            enabledAgents: ['claude-code', 'opencode'],
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        });
+        const claudeBefore = snapshotTree(path_1.default.join(tmpHome, '.claude'));
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit(codexInitOptions());
+        expect(code).toBeLessThanOrEqual(1);
+        expect(readPrefs().defaultAgent).toBe('claude-code');
+        expect(readPrefs().enabledAgents).toEqual(['claude-code', 'opencode', 'codex']); // verifies R11
+        expect(snapshotTree(path_1.default.join(tmpHome, '.claude'))).toEqual(claudeBefore); // verifies R19
+    });
+    it('runs one session in order: version-gate < begin-backup < save-preferences < install-hook < install-bundle', async () => {
+        const calls = [];
+        const installTransaction = require('../../src/core/install-transaction');
+        const realBeginBackupSession = installTransaction.beginBackupSession;
+        jest.spyOn(installTransaction, 'beginBackupSession').mockImplementation((...args) => {
+            calls.push('begin-backup');
+            return realBeginBackupSession(...args);
+        });
+        const config = require('../../src/utils/config');
+        const realSavePreferences = config.savePreferences;
+        jest.spyOn(config, 'savePreferences').mockImplementation((...args) => {
+            calls.push('save-preferences');
+            return realSavePreferences(...args);
+        });
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({
+            cwd: tmpHome,
+            yes: true,
+            actions: fakeActions(calls),
+            assertProviderSupported: () => {
+                calls.push('version-gate');
+                return { provider: 'claude-code', version: null };
+            },
+        });
+        expect(code).toBeLessThanOrEqual(1);
+        const relevant = calls.filter((c) => ['version-gate', 'begin-backup', 'save-preferences', 'install-hook', 'install-bundle'].includes(c));
+        expect(relevant).toEqual(['version-gate', 'begin-backup', 'save-preferences', 'install-hook', 'install-bundle']);
+    });
+    it('rolls back a genuinely-modified target (real hook install) when a later step fails', async () => {
+        // Seed just enough real registry content for the REAL installHook to
+        // succeed and actually merge an AWM entry into settings.json.
+        const contentRoot = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');
+        fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', 'session-start'), '#!/bin/sh\n', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', 'run-hook.cmd'), '#!/bin/sh\n', { mode: 0o755 });
+        fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', 'using-awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'skills', 'using-awm', 'SKILL.md'), '# using-awm');
+        fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.com/baseline.git' }], null, 2));
+        const settingsPath = path_1.default.join(tmpHome, '.claude', 'settings.json');
+        fs_1.default.mkdirSync(path_1.default.dirname(settingsPath), { recursive: true });
+        fs_1.default.writeFileSync(settingsPath, JSON.stringify({ pristine: true, unrelated: 'keep' }, null, 2));
+        const calls = [];
+        const actions = fakeActions(calls);
+        delete actions.installHook; // let the REAL installHook run and genuinely modify settings.json
+        actions.installBundle = () => { throw new Error('boom'); }; // devCore step fails AFTER hook succeeded
+        const { runInit } = require('../../src/commands/init');
+        const code = await runInit({
+            cwd: tmpHome,
+            yes: true,
+            actions,
+        });
+        expect(code).toBe(2);
+        // preferences.json didn't exist before this run — rollback removes it again
+        expect(fs_1.default.existsSync(prefsFile())).toBe(false);
+        // settings.json WAS genuinely modified mid-run (real installHook ran) —
+        // rollback must restore its exact pre-run content, not just leave it be.
+        expect(JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf8'))).toEqual({ pristine: true, unrelated: 'keep' });
+    });
 });

package/dist/tests/commands/multi-agent-targeting.test.js

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/commands/multi-agent-targeting.test.ts
+//
+// R12/R13/R14: `add`, `remove`, `sync`, `update` and `doctor` must all resolve
+// agent targets the same way — every enabled agent when `--agent` is absent,
+// an explicit comma-separated subset when present — and `add` must refuse a
+// selection that would strand a shared artifact target (R14).
+//
+// Each command exposes (or is wired to) a UI-free core that this file drives
+// directly, injecting spies where the command has a real side effect
+// (installBundle / syncProfile / planReconciliation) so the test observes
+// exactly which agent targets that side effect received, without touching
+// real registry content or the network.
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+describe('multi-agent targeting (add/remove/sync/update/doctor)', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-targeting-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    function writePrefs(enabledAgents, defaultAgent = enabledAgents[0]) {
+        const { savePreferences } = require('../../src/utils/config');
+        const prefs = {
+            defaultAgent,
+            enabledAgents,
+            installMethod: 'symlink',
+            defaultScope: 'local',
+        };
+        savePreferences(prefs);
+        return prefs;
+    }
+    function bundle(over = {}) {
+        return {
+            name: 'demo', description: '', version: '1.0.0', scope: 'baseline', visibility: 'public',
+            dependsOn: [], skills: [{ name: 'demo-skill', onSignal: false }], workflows: [], agents: [],
+            ...over,
+        };
+    }
+    async function invokeCommandWithPlannerSpy(command, explicit) {
+        const prefs = writePrefs(['claude-code', 'opencode', 'codex'], 'claude-code');
+        switch (command) {
+            case 'add': {
+                const { runAddBundleCore } = require('../../src/commands/add');
+                let captured = [];
+                const outcome = runAddBundleCore({ name: 'demo', agent: explicit, cwd: tmpHome }, prefs, [bundle()], { addBundle: (o) => { captured = o.agents; return { installed: [], skipped: [], recordedExtension: null, transactionId: 'tx', modifiedFiles: [] }; } });
+                return { selectedAgents: captured, code: outcome.code };
+            }
+            case 'remove': {
+                // remove has no bundle-name concept — it resolves targets the same
+                // way as the other 4 commands (index.ts calls resolveAgentTargets
+                // directly), so this exercises that exact function.
+                const { resolveAgentTargets } = require('../../src/core/agent-targets');
+                const selectedAgents = resolveAgentTargets({ prefs, explicit });
+                return { selectedAgents };
+            }
+            case 'sync': {
+                const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sync-project-'));
+                fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+                fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['demo'] }));
+                const { runSyncCore } = require('../../src/commands/sync');
+                let captured = [];
+                const outcome = await runSyncCore({ cwd: projectRoot, agent: explicit }, {
+                    syncRegistries: async () => [],
+                    verifyMinCliVersions: () => [],
+                    verifyProjectPins: async () => [],
+                    syncProfile: (o) => { captured = o.agents; return { installed: [], skipped: [], extensions: ['demo'], transactionIds: [], modifiedFiles: [] }; },
+                });
+                fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+                return { selectedAgents: captured, code: outcome.code };
+            }
+            case 'update': {
+                const { runUpdateCore } = require('../../src/commands/update');
+                let captured = [];
+                const outcome = await runUpdateCore({ agent: explicit }, {
+                    syncRegistries: async () => [],
+                    verifyMinCliVersions: () => [],
+                    regenerateGlobalContext: () => [],
+                    planReconciliation: (o) => { captured = o.targets; return { operations: [], records: [], reports: [] }; },
+                    applyInstallPlan: () => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }),
+                    resyncInstalledHooks: () => [],
+                    offerSelfUpdate: async () => { },
+                });
+                return { selectedAgents: captured, code: outcome.code };
+            }
+            case 'doctor': {
+                const { runDoctor } = require('../../src/commands/doctor');
+                let captured = [];
+                const { resolveAgentTargets } = require('../../src/core/agent-targets');
+                const code = runDoctor({
+                    cwd: tmpHome,
+                    agent: explicit,
+                    resolveTargets: (input) => {
+                        const resolved = resolveAgentTargets(input);
+                        captured = resolved;
+                        return resolved;
+                    },
+                });
+                return { selectedAgents: captured, code };
+            }
+        }
+    }
+    it.each(['add', 'remove', 'sync', 'update', 'doctor'])('%s targets all enabled providers when --agent is absent', async (command) => {
+        const observed = await invokeCommandWithPlannerSpy(command, undefined);
+        expect(observed.selectedAgents).toEqual(['claude-code', 'opencode', 'codex']); // verifies R12
+    });
+    it.each(['add', 'remove', 'sync', 'update', 'doctor'])('%s honors an independently addressable explicit subset', async (command) => {
+        const observed = await invokeCommandWithPlannerSpy(command, 'codex,claude-code');
+        expect(observed.selectedAgents).toEqual(['codex', 'claude-code']); // verifies R13
+    });
+    // -----------------------------------------------------------------------
+    // R14 — shared-target completeness
+    // -----------------------------------------------------------------------
+    it('add refuses a codex-only skill install when OpenCode (sharing the same skill dir) is also enabled', () => {
+        writePrefs(['opencode', 'codex'], 'opencode');
+        const { runAddBundleCore } = require('../../src/commands/add');
+        const { getPreferences } = require('../../src/utils/config');
+        const outcome = runAddBundleCore({ name: 'demo', agent: 'codex', cwd: tmpHome }, getPreferences(), [bundle()]);
+        expect(outcome.code).toBe(1); // verifies R14 — planInstall's assertCompleteSharedGroup rejects the partial selection
+    });
+    // remove does NOT reproduce add's shared-target refusal by design: R16
+    // says a shared target is *retained* (not deleted, not errored) as long
+    // as another enabled owner remains. Selecting only 'codex' to remove a
+    // skill OpenCode still owns must succeed and leave the shared symlink in
+    // place — documented here since the plan text's "add/remove both fail"
+    // phrasing doesn't hold for remove once R16 is taken into account (see
+    // install-planner.ts's planRemoval, which has no assertCompleteSharedGroup
+    // equivalent, unlike planInstall).
+    it('remove retains (does not error on) a shared skill target still owned by another enabled agent', () => {
+        const { planRemoval } = require('../../src/core/install-planner');
+        const shared = {
+            name: 'demo-skill', type: 'skill', scope: 'global',
+            targetPath: '/home/x/.agents/skills/demo-skill', sourcePath: '/registry/skills/demo-skill',
+            renderer: 'link', owners: ['opencode', 'codex'],
+        };
+        const plan = planRemoval({
+            records: [shared],
+            selectedAgents: ['codex'],
+            enabledAgents: ['opencode', 'codex'],
+            artifactNames: ['demo-skill'],
+        });
+        expect(plan.operations).toEqual([]); // no unlink — still owned by opencode
+        expect(plan.records).toEqual([{ ...shared, owners: ['opencode'] }]);
+    });
+    // -----------------------------------------------------------------------
+    // update: syncs each registry once, then reconciles the full target set once
+    // -----------------------------------------------------------------------
+    it('update syncs registries once and reconciles the resolved targets in a single plan/apply pass', async () => {
+        writePrefs(['claude-code', 'opencode', 'codex'], 'claude-code');
+        // Seed a hooks/ dir so capabilityRoot('hooks') resolves and the hook-resync stage actually runs.
+        const contentRoot = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');
+        fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(process.env.AWM_HOME, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.com/baseline.git' }], null, 2));
+        const { runUpdateCore } = require('../../src/commands/update');
+        const syncRegistries = jest.fn(async () => []);
+        const planReconciliation = jest.fn((o) => ({ operations: [], records: [], reports: [] }));
+        const applyInstallPlan = jest.fn(() => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }));
+        const resyncInstalledHooks = jest.fn(() => []);
+        const outcome = await runUpdateCore({}, {
+            syncRegistries,
+            verifyMinCliVersions: () => [],
+            regenerateGlobalContext: () => [],
+            planReconciliation,
+            applyInstallPlan,
+            resyncInstalledHooks,
+            offerSelfUpdate: async () => { },
+        });
+        expect(outcome.code).toBe(0);
+        expect(syncRegistries).toHaveBeenCalledTimes(1);
+        expect(planReconciliation).toHaveBeenCalledTimes(1);
+        expect(applyInstallPlan).toHaveBeenCalledTimes(1);
+        expect(planReconciliation.mock.calls[0][0].targets).toEqual(['claude-code', 'opencode', 'codex']);
+        expect(resyncInstalledHooks).toHaveBeenCalledTimes(1); // once per update run, not once per provider
+    });
+    it('update reports the failing stage and returns a non-zero exit code instead of swallowing the error', async () => {
+        writePrefs(['claude-code'], 'claude-code');
+        const { runUpdateCore } = require('../../src/commands/update');
+        const outcome = await runUpdateCore({}, {
+            syncRegistries: async () => [],
+            verifyMinCliVersions: () => [],
+            regenerateGlobalContext: () => [],
+            planReconciliation: () => { throw new Error('reconciliation exploded'); },
+            applyInstallPlan: () => ({ installed: [], skipped: [], transactionId: 'tx', modifiedFiles: [] }),
+            resyncInstalledHooks: () => [],
+            offerSelfUpdate: async () => { },
+        });
+        expect(outcome.code).toBe(1); // no silent catch{} — verifies Step 6's "no aborta" removal
+    });
+    it('sync reports a syncProfile failure and returns a non-zero exit code instead of crashing uncaught', async () => {
+        writePrefs(['claude-code'], 'claude-code');
+        const projectRoot = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-sync-project-'));
+        fs_1.default.mkdirSync(path_1.default.join(projectRoot, '.awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(projectRoot, '.awm', 'profile.json'), JSON.stringify({ extensions: ['demo'] }));
+        const { runSyncCore } = require('../../src/commands/sync');
+        let outcome;
+        try {
+            outcome = await runSyncCore({ cwd: projectRoot }, {
+                syncRegistries: async () => [],
+                verifyMinCliVersions: () => [],
+                verifyProjectPins: async () => [],
+                syncProfile: () => { throw new Error('physical target already claimed by a different source'); },
+            });
+        }
+        finally {
+            fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
+        }
+        expect(outcome.code).toBe(1); // no silent catch{} — syncProfile's throw must not propagate uncaught
+    });
+});

package/dist/tests/core/agent-targets.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const agent_targets_1 = require("../../src/core/agent-targets");
+const prefs = {
+    defaultAgent: 'claude-code',
+    enabledAgents: ['claude-code', 'opencode', 'codex'],
+    installMethod: 'symlink',
+    defaultScope: 'local',
+};
+describe('resolveAgentTargets', () => {
+    it('targets every enabled agent when --agent is absent', () => {
+        expect((0, agent_targets_1.resolveAgentTargets)({ prefs, explicit: undefined }))
+            .toEqual(['claude-code', 'opencode', 'codex']);
+    });
+    it('returns a copy without mutating the enabled list', () => {
+        const enabledBefore = [...prefs.enabledAgents];
+        const resolved = (0, agent_targets_1.resolveAgentTargets)({ prefs });
+        expect(resolved).not.toBe(prefs.enabledAgents);
+        expect(prefs.enabledAgents).toEqual(enabledBefore);
+    });
+    it('preserves an exact explicit enabled subset', () => {
+        expect((0, agent_targets_1.resolveAgentTargets)({ prefs, explicit: 'codex,claude-code' }))
+            .toEqual(['codex', 'claude-code']);
+    });
+    it('trims and deduplicates explicit agents in first-seen order', () => {
+        expect((0, agent_targets_1.resolveAgentTargets)({
+            prefs,
+            explicit: ' codex, claude-code,codex,opencode ',
+        })).toEqual(['codex', 'claude-code', 'opencode']);
+    });
+    it('rejects an explicit disabled provider', () => {
+        expect(() => (0, agent_targets_1.resolveAgentTargets)({
+            prefs: { ...prefs, enabledAgents: ['claude-code'] },
+            explicit: 'codex',
+        })).toThrow('codex is not enabled; run awm init --agent codex');
+    });
+    it.each(['', '  ', ' , , '])('rejects empty explicit input %j', (explicit) => {
+        expect(() => (0, agent_targets_1.resolveAgentTargets)({ prefs, explicit }))
+            .toThrow('--agent requires at least one provider');
+    });
+    it('rejects an invalid provider', () => {
+        expect(() => (0, agent_targets_1.resolveAgentTargets)({ prefs, explicit: 'unknown' }))
+            .toThrow('Invalid agent "unknown".');
+    });
+});

package/dist/tests/core/artifact-state.test.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const artifact_state_1 = require("../../src/core/artifact-state");
+describe('artifact-state', () => {
+    let tmpHome;
+    let stateFile;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        // Per CLAUDE.md: no test may touch the real ~/.awm — isolate HOME/AWM_HOME.
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-artifact-state-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        stateFile = path_1.default.join(tmpHome, '.awm', 'state', 'artifacts.json');
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    function record(name, targetPath, owners) {
+        return {
+            name,
+            type: 'skill',
+            scope: 'global',
+            targetPath,
+            sourcePath: path_1.default.join(tmpHome, 'registry', 'skills', name),
+            renderer: 'link',
+            owners,
+        };
+    }
+    describe('artifactStateFile', () => {
+        it('resolves under AWM_HOME/state/artifacts.json', () => {
+            expect((0, artifact_state_1.artifactStateFile)()).toBe(stateFile);
+        });
+    });
+    describe('readArtifactState', () => {
+        it('returns [] when the file does not exist', () => {
+            expect(fs_1.default.existsSync(stateFile)).toBe(false);
+            expect((0, artifact_state_1.readArtifactState)(stateFile)).toEqual([]);
+        });
+        it('throws a clear error on invalid JSON', () => {
+            fs_1.default.mkdirSync(path_1.default.dirname(stateFile), { recursive: true });
+            fs_1.default.writeFileSync(stateFile, '{ not json');
+            expect(() => (0, artifact_state_1.readArtifactState)(stateFile)).toThrow(/not valid JSON/);
+        });
+        it('throws when the parsed content is not an array', () => {
+            fs_1.default.mkdirSync(path_1.default.dirname(stateFile), { recursive: true });
+            fs_1.default.writeFileSync(stateFile, JSON.stringify({ foo: 'bar' }));
+            expect(() => (0, artifact_state_1.readArtifactState)(stateFile)).toThrow(/must contain an array/);
+        });
+        it('defaults to artifactStateFile() when no file is given', () => {
+            expect((0, artifact_state_1.readArtifactState)()).toEqual([]);
+        });
+    });
+    describe('writeArtifactState / round-trip', () => {
+        it('round-trips records written then read back', () => {
+            const records = [
+                record('development-process', path_1.default.join(tmpHome, '.agents/skills/development-process'), ['opencode', 'codex']),
+            ];
+            (0, artifact_state_1.writeArtifactState)(records, stateFile);
+            expect((0, artifact_state_1.readArtifactState)(stateFile)).toEqual(records);
+        });
+        it('sorts output by targetPath deterministically regardless of input order', () => {
+            const b = record('b-skill', path_1.default.join(tmpHome, '.agents/skills/b-skill'), ['codex']);
+            const a = record('a-skill', path_1.default.join(tmpHome, '.agents/skills/a-skill'), ['codex']);
+            const c = record('c-skill', path_1.default.join(tmpHome, '.agents/skills/c-skill'), ['codex']);
+            (0, artifact_state_1.writeArtifactState)([b, c, a], stateFile);
+            const persisted = JSON.parse(fs_1.default.readFileSync(stateFile, 'utf8'));
+            expect(persisted.map((r) => r.targetPath)).toEqual([
+                a.targetPath,
+                b.targetPath,
+                c.targetPath,
+            ]);
+            expect((0, artifact_state_1.readArtifactState)(stateFile)).toEqual([a, b, c]);
+        });
+        it('creates the state directory if missing and writes with restrictive mode', () => {
+            expect(fs_1.default.existsSync(path_1.default.dirname(stateFile))).toBe(false);
+            (0, artifact_state_1.writeArtifactState)([record('s', path_1.default.join(tmpHome, '.agents/skills/s'), ['codex'])], stateFile);
+            expect(fs_1.default.existsSync(stateFile)).toBe(true);
+            expect(fs_1.default.statSync(stateFile).mode & 0o777).toBe(0o600);
+        });
+    });
+    describe('mergeArtifactRecords', () => {
+        it('preserves existing records whose targetPath is not touched by incoming', () => {
+            const a = record('a-skill', path_1.default.join(tmpHome, '.agents/skills/a-skill'), ['codex']);
+            const b = record('b-skill', path_1.default.join(tmpHome, '.agents/skills/b-skill'), ['opencode']);
+            const merged = (0, artifact_state_1.mergeArtifactRecords)([a], [b]);
+            expect(merged).toEqual(expect.arrayContaining([a, b]));
+            expect(merged).toHaveLength(2);
+        });
+        it('replaces the existing record for a targetPath shared with an incoming record, without duplicating it', () => {
+            const targetPath = path_1.default.join(tmpHome, '.agents/skills/shared');
+            const before = record('shared', targetPath, ['codex']);
+            const after = record('shared', targetPath, ['codex', 'opencode']);
+            const merged = (0, artifact_state_1.mergeArtifactRecords)([before], [after]);
+            expect(merged).toHaveLength(1);
+            expect(merged[0]).toEqual(after);
+        });
+        it('simulates a multi-bundle awm init: sequential applyInstallPlan-style merges accumulate, not overwrite', () => {
+            // Mirrors the real bug: several separate applyInstallPlan calls,
+            // each only knowing about the artifacts IT touched, must not
+            // discard each other's records when persisted in sequence.
+            const bundle1 = record('dev-core', path_1.default.join(tmpHome, '.agents/skills/dev-core'), ['claude-code']);
+            const bundle2 = record('ambient', path_1.default.join(tmpHome, '.agents/skills/ambient'), ['codex']);
+            let state = (0, artifact_state_1.mergeArtifactRecords)((0, artifact_state_1.readArtifactState)(stateFile), [bundle1]);
+            (0, artifact_state_1.writeArtifactState)(state, stateFile);
+            state = (0, artifact_state_1.mergeArtifactRecords)((0, artifact_state_1.readArtifactState)(stateFile), [bundle2]);
+            (0, artifact_state_1.writeArtifactState)(state, stateFile);
+            expect((0, artifact_state_1.readArtifactState)(stateFile)).toEqual(expect.arrayContaining([bundle1, bundle2]));
+            expect((0, artifact_state_1.readArtifactState)(stateFile)).toHaveLength(2);
+        });
+        it('updating the same targetPath twice (e.g. re-running init) replaces without duplicating or losing unrelated records', () => {
+            const unrelated = record('unrelated', path_1.default.join(tmpHome, '.agents/skills/unrelated'), ['codex']);
+            const targetPath = path_1.default.join(tmpHome, '.agents/skills/dev-core');
+            const v1 = record('dev-core', targetPath, ['claude-code']);
+            const v2 = record('dev-core', targetPath, ['claude-code', 'opencode']);
+            let state = (0, artifact_state_1.mergeArtifactRecords)((0, artifact_state_1.readArtifactState)(stateFile), [unrelated]);
+            (0, artifact_state_1.writeArtifactState)(state, stateFile);
+            state = (0, artifact_state_1.mergeArtifactRecords)((0, artifact_state_1.readArtifactState)(stateFile), [v1]);
+            (0, artifact_state_1.writeArtifactState)(state, stateFile);
+            state = (0, artifact_state_1.mergeArtifactRecords)((0, artifact_state_1.readArtifactState)(stateFile), [v2]);
+            (0, artifact_state_1.writeArtifactState)(state, stateFile);
+            const final = (0, artifact_state_1.readArtifactState)(stateFile);
+            expect(final).toHaveLength(2);
+            expect(final).toEqual(expect.arrayContaining([unrelated, v2]));
+            expect(final).not.toEqual(expect.arrayContaining([v1]));
+        });
+    });
+});