agentic-workflow-manager 2.0.0

package/README.md

@@ -0,0 +1,62 @@
+# AWM CLI Core
+
+This directory contains the source code for the `agentic-workflow-manager` Command Line Interface.
+
+Built with Node.js and TypeScript, the CLI uses `@clack/prompts` to deliver a zero-friction, interactive Text User Interface (TUI) for installing skills and workflows from configured git registries into the local OS environment.
+
+## 📁 Directory Structure
+
+The CLI is cleanly layered to decouple configuration mapping from core engine logic:
+- `src/index.ts`: The main entrypoint, orchestrating Commander args and Clack prompts.
+- `src/core/`: The core engine modules:
+  - `registry.ts`: Resolves the base registry remote and parses YAML/JSON manifests from `~/.awm/registries/<name>/`.
+  - `discovery.ts`: Provides searching, mapping, and categorization inside the registry format.
+  - `executor.ts`: The installation logic handling target validations, filesystem hooks, Copy execution, and Symlink deployment.
+- `src/providers/`: Encapsulates logic for routing. e.g. mapping `antigravity` to `~/.gemini/antigravity/` vs mapped `opencode` to standard OS `.agents/` targets.
+- `src/utils/`: Common helpers like git wrappers or string formatting flags.
+- `tests/`: Extensive Jest test suites mirroring each module in `src/`.
+
+---
+
+## 🛠 Developer Guide
+
+If you are contributing bug fixes to the CLI or implementing support for a new AI Agent ecosystem (e.g. extending `src/providers/`), follow these steps to work on the CLI locally:
+
+### 1. Requirements
+Ensure you have Node.js and `npm` installed.
+
+### 2. Install Dependencies
+Navigate to this directory (`/cli/`) and install dev packages:
+```bash
+npm install
+```
+
+### 3. Build the CLI
+Because the CLI uses TypeScript, the source must be transpiled to CommonJS/ESM before Node can natively execute the Javascript output via Commander.
+```bash
+npm run build
+```
+This generates the runnable output under `dist/index.js`.
+
+### 4. Running the Tests
+Before submitting a PR, ensure that the core discovery/executor functionality passes the existing test suite:
+```bash
+npm test
+```
+The goal is to maintain 100% passing tests for any new CLI parameter flags.
+
+### 5. Local Execution (Testing changes locally)
+
+**Method A: Typescript Native execution (Slower)**
+Useful for quick testing without building.
+```bash
+npm run start -- add "specific-name" --agent antigravity --scope global
+```
+
+**Method B: Global NPM Linking (Recommended for interactive QA)**
+Links your compiled `dist/` directory directly to your global `awm` path, ensuring you are testing the exact binary output the end-user will see.
+```bash
+npm run build
+npm link
+```
+Now simply type `awm` from any path on your machine.

package/dist/src/commands/doctor.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderReport = renderReport;
+exports.runDoctor = runDoctor;
+exports.registerDoctorCommand = registerDoctorCommand;
+const picocolors_1 = __importDefault(require("picocolors"));
+const context_1 = require("../core/diagnostics/context");
+const checks_1 = require("../core/diagnostics/checks");
+function glyph(status) {
+    if (status === 'ok')
+        return picocolors_1.default.green('✔');
+    if (status === 'warn')
+        return picocolors_1.default.yellow('⚠');
+    return picocolors_1.default.red('✖');
+}
+function remedyText(r) {
+    if (r.remedy.kind === 'command')
+        return picocolors_1.default.dim(`→ ${r.remedy.value}`);
+    if (r.remedy.kind === 'skill')
+        return picocolors_1.default.dim(`→ skill: ${r.remedy.value}`);
+    return '';
+}
+function line(r) {
+    const rem = remedyText(r);
+    const det = r.detail ? picocolors_1.default.dim(` (${r.detail})`) : '';
+    return `  ${glyph(r.status)} ${r.label}${det}${rem ? '   ' + rem : ''}`;
+}
+function renderReport(report) {
+    const lines = [];
+    lines.push(picocolors_1.default.bold('AWM · estado del harness'));
+    lines.push('');
+    lines.push('Máquina (global)');
+    for (const r of report.results.filter((x) => x.level === 'machine'))
+        lines.push(line(r));
+    lines.push('');
+    if (report.hasProject) {
+        lines.push(`Proyecto: ${report.projectName ?? ''}`.trimEnd());
+        for (const r of report.results.filter((x) => x.level === 'project'))
+            lines.push(line(r));
+    }
+    else {
+        lines.push(picocolors_1.default.dim('(sin proyecto en el cwd)'));
+    }
+    lines.push('');
+    const actions = report.results.filter((r) => r.remedy.kind !== 'none').length;
+    const estado = report.overall === 'healthy' ? picocolors_1.default.green('sano') : picocolors_1.default.red('degradado');
+    lines.push(`estado: ${estado} · ${actions} acciones sugeridas`);
+    return lines.join('\n');
+}
+function runDoctor(opts = {}) {
+    let report;
+    try {
+        report = (0, checks_1.runChecks)((0, context_1.gatherContext)({ cwd: opts.cwd }));
+    }
+    catch (err) {
+        process.stderr.write(`awm doctor: error interno: ${err.message}\n`);
+        return 2;
+    }
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    }
+    else {
+        process.stdout.write(renderReport(report) + '\n');
+    }
+    return report.overall === 'healthy' ? 0 : 1;
+}
+function registerDoctorCommand(program) {
+    program.command('doctor')
+        .description('Read-only dashboard of the AWM harness state (machine + project)')
+        .option('--json', 'Emit the diagnostic report as JSON')
+        .action((options) => {
+        process.exitCode = runDoctor({ json: options.json });
+    });
+}

package/dist/src/commands/hooks/index.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHooksCommand = registerHooksCommand;
+const picocolors_1 = __importDefault(require("picocolors"));
+const prompts_1 = require("@clack/prompts");
+const config_1 = require("../../utils/config");
+const install_1 = require("./install");
+const uninstall_1 = require("./uninstall");
+const status_1 = require("./status");
+const registries_1 = require("../../core/registries");
+function registerHooksCommand(program) {
+    const hooks = program.command('hooks').description('Manage SessionStart bootstrap hooks');
+    hooks.command('install')
+        .description('Install the AWM bootstrap hook into the target harness')
+        .option('-t, --target <target>', 'Target harness (claude-code only in this version)', 'claude-code')
+        .option('-y, --yes', 'Skip interactive confirmations', false)
+        .action(async (options) => {
+        const agent = (options.target ?? 'claude-code');
+        const prefs = (0, config_1.getPreferences)();
+        const hooksRoot = (0, registries_1.capabilityRoot)('hooks');
+        if (!hooksRoot) {
+            console.error(picocolors_1.default.red('No configured registry provides hooks/ — run `awm update` first.'));
+            process.exit(1);
+        }
+        try {
+            const result = (0, install_1.installHook)({
+                agent,
+                registryRoot: hooksRoot,
+                installMethod: prefs.installMethod
+            });
+            if (result.status === 'already-up-to-date') {
+                console.log(picocolors_1.default.green('✓ Hook already installed and up-to-date.'));
+                return;
+            }
+            console.log('');
+            console.log(picocolors_1.default.green('✓ AWM bootstrap hook installed.'));
+            console.log('');
+            console.log(`  Scripts:        ${result.scriptsDir}/session-start`);
+            console.log(`                  ${result.scriptsDir}/run-hook.cmd`);
+            console.log(`                  ${result.scriptsDir}/using-awm.md → ~/.awm/registries/baseline/skills/using-awm/SKILL.md`);
+            console.log('');
+            console.log(`  Settings file:  ${result.settingsPath}`);
+            if (result.backupPath) {
+                console.log(`  Backup:         ${result.backupPath}`);
+            }
+            console.log('');
+            console.log('  Active on:      startup | /clear | /compact');
+            console.log('');
+            console.log(`  Verify:         ${picocolors_1.default.cyan('awm hooks status')}`);
+            console.log(`  Remove:         ${picocolors_1.default.cyan('awm hooks uninstall')}`);
+            console.log('');
+            console.log(picocolors_1.default.yellow('  ⚠ Restart Claude Code to activate the hook in existing sessions.'));
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`✗ ${e.message}`));
+            process.exit(1);
+        }
+    });
+    hooks.command('uninstall')
+        .description('Remove the AWM bootstrap hook')
+        .option('-t, --target <target>', 'Target harness (claude-code only in this version)', 'claude-code')
+        .option('-y, --yes', 'Skip interactive confirmations', false)
+        .action(async (options) => {
+        const agent = (options.target ?? 'claude-code');
+        if (!options.yes && process.stdin.isTTY) {
+            const ok = await (0, prompts_1.confirm)({ message: 'Remove AWM bootstrap hook from settings.json?' });
+            if ((0, prompts_1.isCancel)(ok) || ok !== true) {
+                console.log('Cancelled.');
+                return;
+            }
+        }
+        try {
+            const result = (0, uninstall_1.uninstallHook)({ agent });
+            if (result.status === 'not-installed') {
+                console.log(picocolors_1.default.yellow('No AWM hook entry found. Nothing to uninstall.'));
+                return;
+            }
+            console.log(picocolors_1.default.green('✓ AWM bootstrap hook removed.'));
+            if (result.backupPath) {
+                console.log(`  Backup: ${result.backupPath}`);
+            }
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`✗ ${e.message}`));
+            process.exit(1);
+        }
+    });
+    hooks.command('status')
+        .description('Check the bootstrap hook installation status')
+        .option('-t, --target <target>', 'Target harness (claude-code only in this version)', 'claude-code')
+        .action((options) => {
+        const agent = (options.target ?? 'claude-code');
+        try {
+            const result = (0, status_1.computeHookStatus)(agent);
+            const symbol = (ok) => ok ? picocolors_1.default.green('✓') : picocolors_1.default.red('✗');
+            console.log('');
+            console.log(`  Bootstrap skill:    ${symbol(result.checks.bootstrapSkill.ok)} ${result.checks.bootstrapSkill.detail}`);
+            console.log(`  Session-start:      ${symbol(result.checks.sessionStartScript.ok)} ${result.checks.sessionStartScript.detail}`);
+            console.log(`  Run-hook wrapper:   ${symbol(result.checks.runHookWrapper.ok)} ${result.checks.runHookWrapper.detail}`);
+            console.log(`  Settings entry:     ${symbol(result.checks.settingsEntry.ok)} ${result.checks.settingsEntry.detail}`);
+            console.log('');
+            const overall = result.overall === 'HEALTHY' ? picocolors_1.default.green(result.overall) :
+                result.overall === 'NOT_INSTALLED' ? picocolors_1.default.yellow(result.overall) :
+                    picocolors_1.default.red(result.overall);
+            console.log(`  Status: ${overall}`);
+            if (result.overall !== 'HEALTHY') {
+                process.exit(1);
+            }
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(`✗ ${e.message}`));
+            process.exit(1);
+        }
+    });
+}

package/dist/src/commands/hooks/install.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncFile = syncFile;
+exports.installHook = installHook;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+function syncFile(source, dest, method) {
+    try {
+        fs_1.default.unlinkSync(dest);
+    }
+    catch { /* not exists, fine */ }
+    fs_1.default.mkdirSync(path_1.default.dirname(dest), { recursive: true });
+    if (method === 'symlink') {
+        fs_1.default.symlinkSync(source, dest);
+    }
+    else {
+        fs_1.default.copyFileSync(source, dest);
+        const srcMode = fs_1.default.statSync(source).mode;
+        fs_1.default.chmodSync(dest, srcMode);
+    }
+}
+function backupSettings(settingsPath) {
+    if (!fs_1.default.existsSync(settingsPath))
+        return null;
+    const awmHome = process.env.AWM_HOME || path_1.default.join(process.env.HOME, '.awm');
+    const backupDir = path_1.default.join(awmHome, 'backups');
+    fs_1.default.mkdirSync(backupDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '-').slice(0, 19);
+    const backupPath = path_1.default.join(backupDir, `settings.json.${ts}.bak`);
+    fs_1.default.copyFileSync(settingsPath, backupPath);
+    return backupPath;
+}
+function isAwmEntry(entry, scriptsDir, matcher) {
+    return (entry?.matcher === matcher &&
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
+}
+function installHook(options) {
+    const config = (0, providers_1.getHookConfig)(options.agent);
+    if (!config) {
+        throw new Error(`hooks not supported for agent target: ${options.agent}`);
+    }
+    // 1. Verify registry sources exist FIRST (before touching settings)
+    const sourceHooks = path_1.default.join(options.registryRoot, 'hooks');
+    const sourceSkill = path_1.default.join(options.registryRoot, 'skills/using-awm/SKILL.md');
+    if (!fs_1.default.existsSync(path_1.default.join(sourceHooks, 'session-start'))) {
+        throw new Error(`AWM registry not found at ${sourceHooks}. Run 'awm update' to refresh the registry.`);
+    }
+    if (!fs_1.default.existsSync(sourceSkill)) {
+        throw new Error(`using-awm skill not found at ${sourceSkill}. Run 'awm update' first.`);
+    }
+    // 2. Sync scripts
+    fs_1.default.mkdirSync(config.scriptsDir, { recursive: true });
+    syncFile(path_1.default.join(sourceHooks, 'session-start'), path_1.default.join(config.scriptsDir, 'session-start'), options.installMethod);
+    syncFile(path_1.default.join(sourceHooks, 'run-hook.cmd'), path_1.default.join(config.scriptsDir, 'run-hook.cmd'), options.installMethod);
+    // 3. Symlink the skill (ALWAYS symlink so awm update propagates)
+    const skillDest = path_1.default.join(config.scriptsDir, 'using-awm.md');
+    try {
+        fs_1.default.unlinkSync(skillDest);
+    }
+    catch { /* not exists */ }
+    fs_1.default.symlinkSync(sourceSkill, skillDest);
+    // 4. Backup settings if it exists
+    const backupPath = backupSettings(config.settingsPath);
+    // 5. Read or initialize settings
+    let settings = {};
+    if (fs_1.default.existsSync(config.settingsPath)) {
+        const raw = fs_1.default.readFileSync(config.settingsPath, 'utf-8');
+        try {
+            settings = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`${config.settingsPath} is not valid JSON. Backup created at ${backupPath}. Fix the file manually, then re-run.`);
+        }
+    }
+    else {
+        fs_1.default.mkdirSync(path_1.default.dirname(config.settingsPath), { recursive: true });
+    }
+    // 6. Merge AWM entry
+    if (!settings.hooks)
+        settings.hooks = {};
+    if (!settings.hooks[config.eventName])
+        settings.hooks[config.eventName] = [];
+    const entries = settings.hooks[config.eventName];
+    const awmEntryIdx = entries.findIndex((e) => isAwmEntry(e, config.scriptsDir, config.matcher));
+    const newEntry = {
+        matcher: config.matcher,
+        hooks: [{
+                type: 'command',
+                command: `${path_1.default.join(config.scriptsDir, 'run-hook.cmd')} session-start`,
+                async: false
+            }]
+    };
+    let status;
+    if (awmEntryIdx >= 0) {
+        if (JSON.stringify(entries[awmEntryIdx]) === JSON.stringify(newEntry)) {
+            return { status: 'already-up-to-date', scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath: null };
+        }
+        entries[awmEntryIdx] = newEntry;
+        status = 'installed';
+    }
+    else {
+        entries.push(newEntry);
+        status = 'installed';
+    }
+    // 7. Write settings
+    fs_1.default.writeFileSync(config.settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { status, scriptsDir: config.scriptsDir, settingsPath: config.settingsPath, backupPath };
+}

package/dist/src/commands/hooks/resync.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resyncInstalledHooks = resyncInstalledHooks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+const status_1 = require("./status");
+const install_1 = require("./install");
+function detectInstallMethod(scriptsDir) {
+    try {
+        return fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink() ? 'symlink' : 'copy';
+    }
+    catch {
+        return 'copy';
+    }
+}
+function resyncInstalledHooks(registryRoot) {
+    const results = [];
+    for (const agent of Object.keys(providers_1.PROVIDERS)) {
+        const config = (0, providers_1.getHookConfig)(agent);
+        if (!config)
+            continue;
+        const status = (0, status_1.computeHookStatus)(agent);
+        if (!status.checks.settingsEntry.ok) {
+            results.push({ agent, action: 'not-installed' });
+            continue;
+        }
+        const sourceHooks = path_1.default.join(registryRoot, 'hooks');
+        const sourceSkill = path_1.default.join(registryRoot, 'skills/using-awm/SKILL.md');
+        if (!fs_1.default.existsSync(path_1.default.join(sourceHooks, 'session-start')) || !fs_1.default.existsSync(path_1.default.join(sourceHooks, 'run-hook.cmd')) || !fs_1.default.existsSync(sourceSkill)) {
+            results.push({ agent, action: 'registry-missing' });
+            continue;
+        }
+        const method = detectInstallMethod(config.scriptsDir);
+        fs_1.default.mkdirSync(config.scriptsDir, { recursive: true });
+        (0, install_1.syncFile)(path_1.default.join(sourceHooks, 'session-start'), path_1.default.join(config.scriptsDir, 'session-start'), method);
+        (0, install_1.syncFile)(path_1.default.join(sourceHooks, 'run-hook.cmd'), path_1.default.join(config.scriptsDir, 'run-hook.cmd'), method);
+        const skillDest = path_1.default.join(config.scriptsDir, 'using-awm.md');
+        try {
+            fs_1.default.unlinkSync(skillDest);
+        }
+        catch { /* not exists */ }
+        fs_1.default.symlinkSync(sourceSkill, skillDest);
+        results.push({ agent, action: 'resynced' });
+    }
+    return results;
+}

package/dist/src/commands/hooks/status.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHookStatus = computeHookStatus;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+function checkExecutable(file) {
+    if (!fs_1.default.existsSync(file)) {
+        return { ok: false, detail: `missing: ${file}` };
+    }
+    try {
+        fs_1.default.accessSync(file, fs_1.default.constants.X_OK);
+        return { ok: true, detail: file };
+    }
+    catch {
+        return { ok: false, detail: `not executable: ${file}` };
+    }
+}
+function checkFile(file) {
+    if (!fs_1.default.existsSync(file)) {
+        return { ok: false, detail: `missing: ${file}` };
+    }
+    try {
+        fs_1.default.statSync(file);
+        return { ok: true, detail: file };
+    }
+    catch {
+        return { ok: false, detail: `broken link: ${file}` };
+    }
+}
+function checkSettingsEntry(settingsPath, scriptsDir, matcher, eventName) {
+    if (!fs_1.default.existsSync(settingsPath)) {
+        return { ok: false, detail: `settings.json not found: ${settingsPath}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+    }
+    catch {
+        return { ok: false, detail: 'settings.json is not valid JSON' };
+    }
+    const entries = parsed?.hooks?.[eventName] ?? [];
+    const awmEntry = entries.find((e) => e?.matcher === matcher &&
+        (e?.hooks ?? []).some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
+    if (!awmEntry) {
+        return { ok: false, detail: `no AWM SessionStart entry in ${settingsPath}` };
+    }
+    return { ok: true, detail: settingsPath };
+}
+function computeHookStatus(agent) {
+    const config = (0, providers_1.getHookConfig)(agent);
+    if (!config) {
+        throw new Error(`hooks not supported for agent target: ${agent}`);
+    }
+    const checks = {
+        bootstrapSkill: checkFile(path_1.default.join(config.scriptsDir, 'using-awm.md')),
+        sessionStartScript: checkExecutable(path_1.default.join(config.scriptsDir, 'session-start')),
+        runHookWrapper: checkExecutable(path_1.default.join(config.scriptsDir, 'run-hook.cmd')),
+        settingsEntry: checkSettingsEntry(config.settingsPath, config.scriptsDir, config.matcher, config.eventName)
+    };
+    const allOk = Object.values(checks).every((c) => c.ok);
+    const settingsOnlyMissing = !checks.settingsEntry.ok && checks.bootstrapSkill.ok && checks.sessionStartScript.ok && checks.runHookWrapper.ok;
+    let overall;
+    if (allOk)
+        overall = 'HEALTHY';
+    else if (settingsOnlyMissing)
+        overall = 'NOT_INSTALLED';
+    else
+        overall = 'DEGRADED';
+    return { overall, checks };
+}

package/dist/src/commands/hooks/uninstall.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallHook = uninstallHook;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+function backupSettings(settingsPath) {
+    if (!fs_1.default.existsSync(settingsPath))
+        return null;
+    const awmHome = process.env.AWM_HOME || path_1.default.join(process.env.HOME, '.awm');
+    const backupDir = path_1.default.join(awmHome, 'backups');
+    fs_1.default.mkdirSync(backupDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '-').slice(0, 19);
+    const backupPath = path_1.default.join(backupDir, `settings.json.${ts}.bak`);
+    fs_1.default.copyFileSync(settingsPath, backupPath);
+    return backupPath;
+}
+function isAwmEntry(entry, scriptsDir, matcher) {
+    return (entry?.matcher === matcher &&
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(scriptsDir)));
+}
+function uninstallHook(options) {
+    const config = (0, providers_1.getHookConfig)(options.agent);
+    if (!config) {
+        throw new Error(`hooks not supported for agent target: ${options.agent}`);
+    }
+    if (!fs_1.default.existsSync(config.settingsPath)) {
+        return { status: 'not-installed', backupPath: null };
+    }
+    let settings;
+    try {
+        settings = JSON.parse(fs_1.default.readFileSync(config.settingsPath, 'utf-8'));
+    }
+    catch {
+        throw new Error(`${config.settingsPath} is not valid JSON. Manual cleanup required.`);
+    }
+    const entries = settings?.hooks?.[config.eventName] ?? [];
+    const beforeLength = entries.length;
+    const filtered = entries.filter((e) => !isAwmEntry(e, config.scriptsDir, config.matcher));
+    if (filtered.length === beforeLength) {
+        return { status: 'not-installed', backupPath: null };
+    }
+    const backupPath = backupSettings(config.settingsPath);
+    if (filtered.length === 0) {
+        delete settings.hooks[config.eventName];
+        if (Object.keys(settings.hooks).length === 0) {
+            delete settings.hooks;
+        }
+    }
+    else {
+        settings.hooks[config.eventName] = filtered;
+    }
+    fs_1.default.writeFileSync(config.settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { status: 'uninstalled', backupPath };
+}