@rpamis/comet 0.3.9 → 0.4.0-beta.10

package/dist/domains/skill/uninstall.js

@@ -0,0 +1,946 @@
+import path from 'path';
+import { randomUUID } from 'crypto';
+import { hasComparableFileObject, sameFileObject, } from '../../platform/fs/file-identity.js';
+import { classicLayoutPaths } from '../comet-classic/classic-layout.js';
+import { nativeProjectPaths } from '../comet-native/native-paths.js';
+import { readWorkflowProjectConfigIdentity, readWorkflowProjectConfigSnapshot, workflowProjectConfigIdentityEquals, } from '../workflow-contract/project-config-reader.js';
+import { lstat, realpath, rename, rmdir, unlink, writeFile } from 'fs/promises';
+import { fileExists, readDir, removeFile, removeDir, isDirEmpty, } from '../../platform/fs/file-system.js';
+import { getPlatformConfigDir, getPlatformSkillsDir, getPlatformSkillsDirs, } from '../../platform/install/platforms.js';
+import { readManifest, getManagedSkillPaths, computeRuleDestPath, isManagedHookCommand, removeManagedHooksFromJsonFile, } from './platform-install.js';
+import { removeCometProjectInstructions } from './project-instructions.js';
+import { readJsonObjectFile } from './json-object.js';
+const OPENCODE_STYLE_PLATFORM_IDS = new Set(['opencode', 'mimocode']);
+const LEGACY_RULE_PATHS = [
+    'comet/rules/comet-phase-guard.md',
+    'comet-native/rules/comet-native-phase-guard.md',
+];
+const LEGACY_HOOK_SCRIPT_PATHS = [
+    'comet/scripts/comet-hook-guard.mjs',
+    'comet-native/scripts/comet-native-hook-guard.mjs',
+];
+function managedWorkingTreeEntry(tree, entry) {
+    return Object.prototype.hasOwnProperty.call(tree, entry) ? tree[entry] : undefined;
+}
+function setManagedWorkingTreeEntry(tree, entry, value) {
+    Object.defineProperty(tree, entry, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true,
+    });
+}
+const EMPTY_MANAGED_WORKING_TREE = {};
+const OPENSPEC_WORKING_TREE = {
+    changes: {
+        archive: EMPTY_MANAGED_WORKING_TREE,
+    },
+    specs: EMPTY_MANAGED_WORKING_TREE,
+};
+const SUPERPOWERS_WORKING_TREE = {
+    specs: EMPTY_MANAGED_WORKING_TREE,
+    plans: EMPTY_MANAGED_WORKING_TREE,
+    reports: EMPTY_MANAGED_WORKING_TREE,
+};
+const COMET_WORKING_TREE = {
+    'config.yaml': 'file',
+};
+const NATIVE_WORKING_TREE = {
+    specs: EMPTY_MANAGED_WORKING_TREE,
+    changes: EMPTY_MANAGED_WORKING_TREE,
+    archive: EMPTY_MANAGED_WORKING_TREE,
+    runtime: {
+        locks: EMPTY_MANAGED_WORKING_TREE,
+        transactions: EMPTY_MANAGED_WORKING_TREE,
+    },
+};
+function birthtimeOf(stat) {
+    return stat.birthtimeNs;
+}
+function workingIdentity(stat) {
+    return {
+        kind: stat.isFile() ? 'file' : 'directory',
+        fileObject: { dev: stat.dev, ino: stat.ino, birthtime: birthtimeOf(stat) },
+        size: stat.size,
+    };
+}
+function sameWorkingIdentity(expected, actual) {
+    if (expected.kind !== actual.kind)
+        return false;
+    if (hasComparableFileObject(expected.fileObject, actual.fileObject) &&
+        !sameFileObject(expected.fileObject, actual.fileObject)) {
+        return false;
+    }
+    if (!hasComparableFileObject(expected.fileObject, actual.fileObject) &&
+        !sameFileObject(expected.fileObject, actual.fileObject)) {
+        return false;
+    }
+    return expected.kind === 'directory' || expected.size === actual.size;
+}
+function isInsideDirectory(parent, target) {
+    const relative = path.relative(parent, target);
+    return (relative === '' ||
+        (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`)));
+}
+async function readWorkingObjectIdentity(target, expected) {
+    const stat = await lstat(target, { bigint: true });
+    if (stat.isSymbolicLink() || (expected === 'file' ? !stat.isFile() : !stat.isDirectory())) {
+        throw new Error(`Refusing to remove non-${expected} working object: ${target}`);
+    }
+    return workingIdentity(stat);
+}
+async function captureAncestorIdentities(projectRoot, directory) {
+    if (!isInsideDirectory(projectRoot, directory)) {
+        throw new Error(`Working directory is outside the project root: ${directory}`);
+    }
+    const identities = new Map();
+    let cursor = projectRoot;
+    identities.set(path.resolve(cursor), await readWorkingObjectIdentity(cursor, 'directory'));
+    const relative = path.relative(projectRoot, directory);
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        cursor = path.join(cursor, segment);
+        identities.set(path.resolve(cursor), await readWorkingObjectIdentity(cursor, 'directory'));
+    }
+    return identities;
+}
+async function assertIdentityChain(projectRoot, target, identities) {
+    if (!isInsideDirectory(projectRoot, target)) {
+        throw new Error(`Working directory is outside the project root: ${target}`);
+    }
+    let cursor = projectRoot;
+    const paths = [cursor];
+    const relative = path.relative(projectRoot, target);
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        cursor = path.join(cursor, segment);
+        paths.push(cursor);
+    }
+    for (const current of paths) {
+        const expected = identities.get(path.resolve(current));
+        if (!expected) {
+            throw new Error(`Working-directory identity is not bound: ${current}`);
+        }
+        const actual = await readWorkingObjectIdentity(current, expected.kind);
+        if (!sameWorkingIdentity(expected, actual)) {
+            throw new Error(`Working-directory object changed after inspection: ${current}`);
+        }
+    }
+}
+async function inspectManagedNode(projectRoot, directory, managedTree, identities) {
+    const identity = identities.get(path.resolve(directory));
+    if (!identity)
+        throw new Error(`Working-directory identity is not bound: ${directory}`);
+    const entries = (await readDir(directory)).sort();
+    await assertIdentityChain(projectRoot, directory, identities);
+    const children = new Map();
+    for (const entry of entries) {
+        if (!Object.prototype.hasOwnProperty.call(managedTree, entry)) {
+            throw new Error(`Refusing to remove unknown working-directory content: ${path.join(directory, entry)}`);
+        }
+        const expected = managedTree[entry];
+        const entryPath = path.join(directory, entry);
+        if (expected === 'file') {
+            const childIdentity = await readWorkingObjectIdentity(entryPath, 'file');
+            identities.set(path.resolve(entryPath), childIdentity);
+            children.set(entry, { identity: childIdentity, children: null });
+            continue;
+        }
+        const childIdentity = await readWorkingObjectIdentity(entryPath, 'directory');
+        identities.set(path.resolve(entryPath), childIdentity);
+        children.set(entry, await inspectManagedNode(projectRoot, entryPath, expected, identities));
+    }
+    const entriesAfter = (await readDir(directory)).sort();
+    await assertIdentityChain(projectRoot, directory, identities);
+    if (JSON.stringify(entriesAfter) !== JSON.stringify(entries)) {
+        throw new Error(`Working directory changed during inspection: ${directory}`);
+    }
+    return { identity, children };
+}
+async function inspectManagedWorkingTree(projectRoot, directory, managedTree, countRemoval = false) {
+    try {
+        const ancestorIdentities = await captureAncestorIdentities(projectRoot, directory);
+        return {
+            directory,
+            managedTree,
+            root: await inspectManagedNode(projectRoot, directory, managedTree, ancestorIdentities),
+            ancestorIdentities,
+            countRemoval,
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function validateManagedNode(projectRoot, directory, node, identities) {
+    await assertIdentityChain(projectRoot, directory, identities);
+    const actualIdentity = await readWorkingObjectIdentity(directory, node.identity.kind);
+    if (!sameWorkingIdentity(node.identity, actualIdentity)) {
+        throw new Error(`Working-directory object changed after inspection: ${directory}`);
+    }
+    if (!node.children)
+        return;
+    const entries = (await readDir(directory)).sort();
+    await assertIdentityChain(projectRoot, directory, identities);
+    const expectedEntries = [...node.children.keys()].sort();
+    if (JSON.stringify(entries) !== JSON.stringify(expectedEntries)) {
+        throw new Error(`Working directory changed after inspection: ${directory}`);
+    }
+    for (const entry of expectedEntries) {
+        await validateManagedNode(projectRoot, path.join(directory, entry), node.children.get(entry), identities);
+    }
+    const entriesAfter = (await readDir(directory)).sort();
+    await assertIdentityChain(projectRoot, directory, identities);
+    if (JSON.stringify(entriesAfter) !== JSON.stringify(expectedEntries)) {
+        throw new Error(`Working directory changed after inspection: ${directory}`);
+    }
+}
+async function validateManagedWorkingTree(projectRoot, plan) {
+    await validateManagedNode(projectRoot, plan.directory, plan.root, plan.ancestorIdentities);
+}
+function mergeManagedWorkingTree(target, segments, managedTree) {
+    if (segments.length === 0) {
+        for (const [entry, expected] of Object.entries(managedTree)) {
+            const current = managedWorkingTreeEntry(target, entry);
+            if (current === 'file' || expected === 'file') {
+                if (current !== undefined && current !== expected) {
+                    throw new Error(`Conflicting managed working-tree entry: ${entry}`);
+                }
+                setManagedWorkingTreeEntry(target, entry, expected);
+            }
+            else if (current === undefined) {
+                setManagedWorkingTreeEntry(target, entry, expected);
+            }
+            else {
+                mergeManagedWorkingTree(current, [], expected);
+            }
+        }
+        return;
+    }
+    const [head, ...tail] = segments;
+    const current = managedWorkingTreeEntry(target, head);
+    if (current === 'file')
+        throw new Error(`Conflicting managed working-tree entry: ${head}`);
+    const child = current ?? Object.create(null);
+    setManagedWorkingTreeEntry(target, head, child);
+    mergeManagedWorkingTree(child, tail, managedTree);
+}
+function cloneManagedWorkingTree(managedTree) {
+    return Object.fromEntries(Object.entries(managedTree).map(([entry, expected]) => [
+        entry,
+        expected === 'file' ? expected : cloneManagedWorkingTree(expected),
+    ]));
+}
+async function assertWorkingTreeAbsentOrRealDirectory(projectRoot, directory) {
+    try {
+        await captureAncestorIdentities(projectRoot, directory);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function realWorkingFileExists(file) {
+    try {
+        await readWorkingObjectIdentity(file, 'file');
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function validateQuarantinedNode(directory, node, ancestors) {
+    await assertQuarantineAncestorIdentities(ancestors);
+    const actual = await readWorkingObjectIdentity(directory, node.identity.kind);
+    if (!sameWorkingIdentity(node.identity, actual)) {
+        throw new Error(`Quarantined working object changed: ${directory}`);
+    }
+    if (!node.children)
+        return;
+    const entries = (await readDir(directory)).sort();
+    await assertQuarantineAncestorIdentities(ancestors);
+    const expectedEntries = [...node.children.keys()].sort();
+    const after = await readWorkingObjectIdentity(directory, 'directory');
+    if (!sameWorkingIdentity(node.identity, after) ||
+        JSON.stringify(entries) !== JSON.stringify(expectedEntries)) {
+        throw new Error(`Quarantined working directory changed: ${directory}`);
+    }
+    for (const entry of expectedEntries) {
+        await validateQuarantinedNode(path.join(directory, entry), node.children.get(entry), [
+            ...ancestors,
+            { path: directory, identity: node.identity },
+        ]);
+    }
+    const entriesAfter = (await readDir(directory)).sort();
+    await assertQuarantineAncestorIdentities(ancestors);
+    const finalIdentity = await readWorkingObjectIdentity(directory, 'directory');
+    if (!sameWorkingIdentity(node.identity, finalIdentity) ||
+        JSON.stringify(entriesAfter) !== JSON.stringify(expectedEntries)) {
+        throw new Error(`Quarantined working directory changed: ${directory}`);
+    }
+}
+async function assertQuarantineAncestorIdentities(ancestors) {
+    for (const ancestor of ancestors) {
+        const actual = await readWorkingObjectIdentity(ancestor.path, 'directory');
+        if (!sameWorkingIdentity(ancestor.identity, actual)) {
+            throw new Error(`Quarantine ancestor changed: ${ancestor.path}`);
+        }
+    }
+}
+async function removeQuarantinedNode(directory, node, ancestors) {
+    await assertQuarantineAncestorIdentities(ancestors);
+    const actual = await readWorkingObjectIdentity(directory, node.identity.kind);
+    if (!sameWorkingIdentity(node.identity, actual)) {
+        throw new Error(`Quarantined working object changed: ${directory}`);
+    }
+    if (!node.children) {
+        await unlink(directory);
+        return;
+    }
+    for (const [entry, child] of node.children) {
+        await removeQuarantinedNode(path.join(directory, entry), child, [
+            ...ancestors,
+            { path: directory, identity: node.identity },
+        ]);
+    }
+    const entries = await readDir(directory);
+    await assertQuarantineAncestorIdentities(ancestors);
+    const after = await readWorkingObjectIdentity(directory, 'directory');
+    if (!sameWorkingIdentity(node.identity, after) || entries.length !== 0) {
+        throw new Error(`Quarantined working directory changed before removal: ${directory}`);
+    }
+    await assertQuarantineAncestorIdentities(ancestors);
+    const beforeRemove = await readWorkingObjectIdentity(directory, 'directory');
+    if (!sameWorkingIdentity(node.identity, beforeRemove)) {
+        throw new Error(`Quarantined working directory changed before removal: ${directory}`);
+    }
+    await rmdir(directory);
+}
+function quarantineAncestorChain(plan) {
+    const parent = path.dirname(plan.directory);
+    return [...plan.ancestorIdentities.entries()]
+        .filter(([candidate]) => candidate !== path.resolve(plan.directory))
+        .filter(([candidate]) => isInsideDirectory(candidate, parent))
+        .sort(([left], [right]) => left.split(path.sep).length - right.split(path.sep).length)
+        .map(([ancestorPath, identity]) => ({ path: ancestorPath, identity }));
+}
+async function rollbackQuarantinedTrees(quarantined) {
+    for (const item of [...quarantined].reverse()) {
+        try {
+            await rename(item.quarantine, item.plan.directory);
+        }
+        catch {
+            // Preserve the original failure. A conflicting replacement remains
+            // visible for explicit repair instead of being overwritten.
+        }
+    }
+}
+async function removeManagedWorkingTree(projectRoot, plans) {
+    for (const plan of plans) {
+        await validateManagedWorkingTree(projectRoot, plan);
+    }
+    // Preserve the existing retry contract for a config directory whose final
+    // rmdir is denied, while ensuring this probe happens before any tree moves.
+    const configPlan = plans.find((plan) => plan.countRemoval);
+    if (configPlan?.root.children && configPlan.root.children.size > 0) {
+        try {
+            await rmdir(configPlan.directory);
+            throw new Error('Managed config directory changed after inspection');
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOTEMPTY' && code !== 'EEXIST')
+                throw error;
+        }
+    }
+    const quarantined = [];
+    try {
+        for (const plan of plans) {
+            await validateManagedWorkingTree(projectRoot, plan);
+            const ancestors = quarantineAncestorChain(plan);
+            await assertQuarantineAncestorIdentities(ancestors);
+            const quarantine = path.join(path.dirname(plan.directory), `.${path.basename(plan.directory)}.comet-uninstall-${randomUUID()}`);
+            try {
+                await lstat(quarantine);
+                throw new Error(`Uninstall quarantine already exists: ${quarantine}`);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            await rename(plan.directory, quarantine);
+            const item = { plan, quarantine };
+            quarantined.push(item);
+            await assertQuarantineAncestorIdentities(ancestors);
+            await validateQuarantinedNode(quarantine, plan.root, ancestors);
+        }
+    }
+    catch (error) {
+        await rollbackQuarantinedTrees(quarantined);
+        throw error;
+    }
+    let removed = 0;
+    try {
+        for (const item of quarantined) {
+            await removeQuarantinedNode(item.quarantine, item.plan.root, quarantineAncestorChain(item.plan));
+            if (item.plan.countRemoval)
+                removed++;
+        }
+    }
+    catch {
+        const remaining = [];
+        for (const item of quarantined) {
+            try {
+                await lstat(item.quarantine);
+                remaining.push(item);
+            }
+            catch {
+                // A fully removed quarantine has nothing left to restore.
+            }
+        }
+        await rollbackQuarantinedTrees(remaining);
+        return { removed, failed: 1 };
+    }
+    return { removed, failed: 0 };
+}
+async function removeManagedSkillsFromDirs(baseDir, skillsDirs, managedSkills) {
+    let removed = 0;
+    let failed = 0;
+    const parentDirs = new Set();
+    for (const skillsDir of skillsDirs) {
+        const platformRoot = path.join(baseDir, skillsDir);
+        const skillsRoot = path.join(baseDir, skillsDir, 'skills');
+        let sharedBoundary = false;
+        for (const boundary of [platformRoot, skillsRoot]) {
+            try {
+                if ((await lstat(boundary)).isSymbolicLink()) {
+                    failed++;
+                    sharedBoundary = true;
+                    break;
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    failed++;
+                    sharedBoundary = true;
+                    break;
+                }
+            }
+        }
+        if (sharedBoundary)
+            continue;
+        for (const skillRelPath of managedSkills) {
+            try {
+                const parts = skillRelPath.split('/');
+                let current = baseDir;
+                let linkedAncestor = false;
+                const ancestorParts = [
+                    ...skillsDir.split(/[\\/]/u).filter(Boolean),
+                    'skills',
+                    ...parts.slice(0, -1),
+                ];
+                for (const part of ancestorParts) {
+                    current = path.join(current, part);
+                    if ((await lstat(current)).isSymbolicLink()) {
+                        if (await removeFile(current))
+                            removed++;
+                        linkedAncestor = true;
+                        break;
+                    }
+                }
+                if (linkedAncestor)
+                    continue;
+                if (await removeFile(path.join(skillsRoot, ...parts)))
+                    removed++;
+                current = skillsRoot;
+                for (const part of parts.slice(0, -1)) {
+                    current = path.join(current, part);
+                    parentDirs.add(current);
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    failed++;
+            }
+        }
+    }
+    for (const dir of [...parentDirs].sort((left, right) => right.split(path.sep).length - left.split(path.sep).length)) {
+        try {
+            if (await isDirEmpty(dir))
+                await removeDir(dir);
+        }
+        catch {
+            failed++;
+        }
+    }
+    return { removed, failed };
+}
+export async function removeLegacyCometSkillsForPlatform(baseDir, platform, scope = 'project') {
+    const canonicalDir = getPlatformSkillsDir(platform, scope);
+    const legacyDirs = getPlatformSkillsDirs(platform, scope).filter((dir) => dir !== canonicalDir);
+    if (legacyDirs.length === 0)
+        return { removed: 0, failed: 0 };
+    const managedSkills = getManagedSkillPaths(await readManifest());
+    return removeManagedSkillsFromDirs(baseDir, legacyDirs, managedSkills);
+}
+async function removeCometSkillsForPlatform(baseDir, platform, scope = 'project') {
+    const manifest = await readManifest();
+    const managedSkills = getManagedSkillPaths(manifest);
+    const skillsDir = getPlatformSkillsDir(platform, scope);
+    const uniqueSkillsDirs = [
+        ...new Set([
+            ...getPlatformSkillsDirs(platform, scope),
+            ...(scope === 'global' && platform.id === 'pi' ? [platform.skillsDir] : []),
+        ]),
+    ];
+    const skillsRemoval = await removeManagedSkillsFromDirs(baseDir, uniqueSkillsDirs, managedSkills);
+    let removed = skillsRemoval.removed;
+    let failed = skillsRemoval.failed;
+    if (OPENCODE_STYLE_PLATFORM_IDS.has(platform.id)) {
+        const commandsDir = path.join(baseDir, skillsDir, 'commands');
+        for (const skillRelPath of manifest.skills) {
+            const parts = skillRelPath.split('/');
+            if (parts.length !== 2 || parts[1] !== 'SKILL.md')
+                continue;
+            const skillName = parts[0];
+            const commandFile = path.join(commandsDir, `${skillName}.md`);
+            try {
+                const result = await removeFile(commandFile);
+                if (result) {
+                    removed++;
+                }
+            }
+            catch {
+                failed++;
+            }
+        }
+    }
+    if (platform.id === 'pi') {
+        const extensionsDir = path.join(baseDir, skillsDir, 'extensions');
+        try {
+            if (await removeFile(path.join(extensionsDir, 'comet-commands.ts'))) {
+                removed++;
+            }
+        }
+        catch {
+            failed++;
+        }
+        try {
+            if (await isDirEmpty(extensionsDir)) {
+                await removeDir(extensionsDir);
+            }
+        }
+        catch {
+            failed++;
+        }
+    }
+    return { removed, failed };
+}
+async function removeCometRulesForPlatform(baseDir, platform, scope = 'project') {
+    if (!platform.rulesDir || !platform.rulesFormat) {
+        return { removed: 0, failed: 0 };
+    }
+    const manifest = await readManifest();
+    const rulePaths = [
+        ...(manifest.rules ?? []),
+        ...(manifest.nativeRules ?? []),
+        ...LEGACY_RULE_PATHS,
+    ];
+    if (!rulePaths || rulePaths.length === 0) {
+        return { removed: 0, failed: 0 };
+    }
+    const skillsDir = getPlatformSkillsDir(platform, scope);
+    const rulesBase = platform.rulesBaseDir !== undefined
+        ? platform.rulesBaseDir === ''
+            ? baseDir
+            : path.join(baseDir, platform.rulesBaseDir)
+        : path.join(baseDir, skillsDir);
+    let removed = 0;
+    let failed = 0;
+    for (const ruleRelPath of rulePaths) {
+        const ruleFileName = path.basename(ruleRelPath);
+        const rulesDestDir = path.join(rulesBase, platform.rulesDir);
+        const dest = computeRuleDestPath(rulesDestDir, ruleFileName, platform.rulesFormat);
+        try {
+            const result = await removeFile(dest);
+            if (result) {
+                removed++;
+            }
+        }
+        catch {
+            failed++;
+        }
+    }
+    const rulesDestDir = path.join(rulesBase, platform.rulesDir);
+    try {
+        if (await isDirEmpty(rulesDestDir)) {
+            await removeDir(rulesDestDir);
+        }
+    }
+    catch {
+        failed++;
+    }
+    return { removed, failed };
+}
+async function removeCometHooksForPlatform(baseDir, platform, scope = 'project') {
+    if (!platform.supportsHooks || !platform.hookFormat) {
+        return { removed: 0, failed: 0 };
+    }
+    const manifest = await readManifest();
+    const hooksConfig = { ...(manifest.hooks ?? {}), ...(manifest.nativeHooks ?? {}) };
+    if (!hooksConfig || Object.keys(hooksConfig).length === 0) {
+        return { removed: 0, failed: 0 };
+    }
+    const hookFormat = platform.hookFormat;
+    const platformBase = path.join(baseDir, getPlatformConfigDir(platform, scope));
+    const scriptRelPaths = [...new Set([...Object.keys(hooksConfig), ...LEGACY_HOOK_SCRIPT_PATHS])];
+    try {
+        switch (hookFormat) {
+            case 'claude-code': {
+                const canonicalFile = platform.hookConfigFile ?? 'settings.local.json';
+                const files = [canonicalFile, ...(platform.legacyHookConfigFiles ?? [])];
+                let removed = 0;
+                let failed = 0;
+                for (const file of new Set(files)) {
+                    let result;
+                    try {
+                        result = await removeManagedHooksFromJsonFile(path.join(platformBase, file), scriptRelPaths);
+                    }
+                    catch {
+                        if (file === canonicalFile)
+                            failed++;
+                        continue;
+                    }
+                    removed += result.removed;
+                    if (file === canonicalFile)
+                        failed += result.failed;
+                }
+                return { removed, failed };
+            }
+            case 'qwen':
+            case 'qoder':
+            case 'codebuddy':
+                return await removeQwenStyleHooks(platformBase, scriptRelPaths);
+            case 'gemini':
+                return await removeGeminiHooks(platformBase, scriptRelPaths);
+            case 'windsurf':
+                return await removeWindsurfHooks(platformBase, scriptRelPaths);
+            case 'copilot':
+                return await removeCopilotHooks(platformBase);
+            case 'kiro':
+                return await removeKiroHooks(platformBase, scriptRelPaths);
+            default:
+                return { removed: 0, failed: 0 };
+        }
+    }
+    catch {
+        return { removed: 0, failed: 1 };
+    }
+}
+async function removeQwenStyleHooks(platformBase, scriptRelPaths) {
+    const settingsPath = path.join(platformBase, 'settings.json');
+    if (!(await fileExists(settingsPath)))
+        return { removed: 0, failed: 0 };
+    let removed = 0;
+    const readResult = await readJsonObjectFile(settingsPath);
+    if (readResult.status === 'missing')
+        return { removed: 0, failed: 0 };
+    if (readResult.status === 'error')
+        return { removed: 0, failed: 1 };
+    const settings = readResult.value;
+    const existingHooks = settings.hooks;
+    if (!existingHooks) {
+        return { removed: 0, failed: 0 };
+    }
+    const existingPreToolUse = existingHooks.PreToolUse;
+    if (!existingPreToolUse || !Array.isArray(existingPreToolUse)) {
+        return { removed: 0, failed: 0 };
+    }
+    const filtered = existingPreToolUse.flatMap((group) => {
+        if (!Array.isArray(group.hooks))
+            return [group];
+        const hooksBefore = group.hooks.length;
+        const hooks = group.hooks.filter((hook) => !isManagedHookCommand(hook.command, scriptRelPaths));
+        removed += hooksBefore - hooks.length;
+        const hasUnknownMetadata = Object.keys(group).some((key) => key !== 'matcher' && key !== 'hooks');
+        if (hooks.length === 0)
+            return hasUnknownMetadata ? [{ ...group, hooks: [] }] : [];
+        return [{ ...group, hooks }];
+    });
+    if (filtered.length === 0) {
+        delete existingHooks.PreToolUse;
+    }
+    else {
+        existingHooks.PreToolUse = filtered;
+    }
+    if (Object.keys(existingHooks).length === 0) {
+        delete settings.hooks;
+    }
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { removed, failed: 0 };
+}
+async function removeGeminiHooks(platformBase, scriptRelPaths) {
+    const settingsPath = path.join(platformBase, 'settings.json');
+    if (!(await fileExists(settingsPath)))
+        return { removed: 0, failed: 0 };
+    let removed = 0;
+    const readResult = await readJsonObjectFile(settingsPath);
+    if (readResult.status === 'missing')
+        return { removed: 0, failed: 0 };
+    if (readResult.status === 'error')
+        return { removed: 0, failed: 1 };
+    const settings = readResult.value;
+    const existingHooks = settings.hooks;
+    if (!existingHooks) {
+        return { removed: 0, failed: 0 };
+    }
+    const existingBeforeTool = existingHooks.BeforeTool;
+    if (!existingBeforeTool || !Array.isArray(existingBeforeTool)) {
+        return { removed: 0, failed: 0 };
+    }
+    const filtered = existingBeforeTool.flatMap((group) => {
+        if (!Array.isArray(group.hooks))
+            return [group];
+        const hooksBefore = group.hooks.length;
+        const hooks = group.hooks.filter((hook) => !isManagedHookCommand(hook.command, scriptRelPaths));
+        removed += hooksBefore - hooks.length;
+        const hasUnknownMetadata = Object.keys(group).some((key) => key !== 'matcher' && key !== 'hooks');
+        if (hooks.length === 0)
+            return hasUnknownMetadata ? [{ ...group, hooks: [] }] : [];
+        return [{ ...group, hooks }];
+    });
+    if (filtered.length === 0) {
+        delete existingHooks.BeforeTool;
+    }
+    else {
+        existingHooks.BeforeTool = filtered;
+    }
+    if (Object.keys(existingHooks).length === 0) {
+        delete settings.hooks;
+    }
+    await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    return { removed, failed: 0 };
+}
+async function removeWindsurfHooks(platformBase, scriptRelPaths) {
+    const hooksPath = path.join(platformBase, 'hooks.json');
+    if (!(await fileExists(hooksPath)))
+        return { removed: 0, failed: 0 };
+    let removed = 0;
+    const readResult = await readJsonObjectFile(hooksPath);
+    if (readResult.status === 'missing')
+        return { removed: 0, failed: 0 };
+    if (readResult.status === 'error')
+        return { removed: 0, failed: 1 };
+    const hooksFile = readResult.value;
+    const existingHooks = hooksFile.hooks;
+    if (!existingHooks) {
+        return { removed: 0, failed: 0 };
+    }
+    const existingPreWrite = existingHooks.pre_write_code;
+    if (!existingPreWrite || !Array.isArray(existingPreWrite)) {
+        return { removed: 0, failed: 0 };
+    }
+    const filtered = existingPreWrite.filter((entry) => {
+        if (isManagedHookCommand(entry.command, scriptRelPaths)) {
+            removed++;
+            return false;
+        }
+        return true;
+    });
+    if (filtered.length === 0) {
+        delete existingHooks.pre_write_code;
+    }
+    else {
+        existingHooks.pre_write_code = filtered;
+    }
+    if (Object.keys(existingHooks).length === 0) {
+        delete hooksFile.hooks;
+    }
+    await writeFile(hooksPath, JSON.stringify(hooksFile, null, 2) + '\n', 'utf-8');
+    return { removed, failed: 0 };
+}
+async function removeCopilotHooks(platformBase) {
+    const hookFilePath = path.join(platformBase, 'hooks', 'comet-guard.json');
+    let removed = 0;
+    let failed = 0;
+    try {
+        if (await removeFile(hookFilePath))
+            removed++;
+    }
+    catch {
+        failed++;
+    }
+    const hooksDir = path.join(platformBase, 'hooks');
+    try {
+        if (await isDirEmpty(hooksDir)) {
+            await removeDir(hooksDir);
+        }
+    }
+    catch {
+        failed++;
+    }
+    return { removed, failed };
+}
+async function removeKiroHooks(platformBase, scriptRelPaths) {
+    const hooksDir = path.join(platformBase, 'hooks');
+    try {
+        if (!(await lstat(hooksDir)).isDirectory()) {
+            return { removed: 0, failed: 1 };
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { removed: 0, failed: 0 };
+        }
+        return { removed: 0, failed: 1 };
+    }
+    let removed = 0;
+    let failed = 0;
+    const entries = await readDir(hooksDir);
+    for (const entry of entries) {
+        if (!entry.endsWith('.kiro.hook'))
+            continue;
+        const baseName = entry.replace('.kiro.hook', '');
+        const isCometHook = scriptRelPaths.some((scriptPath) => {
+            const scriptBase = path.basename(scriptPath).replace(/\.mjs$/u, '');
+            return scriptBase === baseName;
+        });
+        if (isCometHook) {
+            const hookPath = path.join(hooksDir, entry);
+            try {
+                if (await removeFile(hookPath)) {
+                    removed++;
+                }
+            }
+            catch {
+                failed++;
+            }
+        }
+    }
+    try {
+        if (await isDirEmpty(hooksDir)) {
+            await removeDir(hooksDir);
+        }
+    }
+    catch {
+        failed++;
+    }
+    return { removed, failed };
+}
+async function removeWorkingDirs(projectPath, options = {}) {
+    let projectRoot;
+    try {
+        projectRoot = await realpath(projectPath);
+        const rootStat = await lstat(projectRoot, { bigint: true });
+        if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
+            return { removed: 0, failed: 1 };
+        }
+    }
+    catch {
+        return { removed: 0, failed: 1 };
+    }
+    const cometDir = path.join(projectRoot, '.comet');
+    const docsDir = path.join(projectRoot, 'docs');
+    const legacyOpenSpecRoot = path.join(projectRoot, 'openspec');
+    const docsOpenSpecRoot = path.join(docsDir, 'openspec');
+    let plans;
+    let configIdentity;
+    try {
+        const snapshot = await readWorkflowProjectConfigSnapshot(projectRoot, {
+            allowPartialProject: true,
+        });
+        const document = snapshot.document;
+        configIdentity = snapshot.identity;
+        const configuredWorkflows = document?.config
+            ? (document.config.workflows ?? [document.config.default_workflow])
+            : [];
+        const classicEnabled = configuredWorkflows.includes('classic') || document?.classic !== undefined;
+        const nativeEnabled = configuredWorkflows.includes('native') || document?.native !== undefined;
+        const artifactLayout = classicEnabled ? (document?.classic?.artifact_layout ?? 'legacy') : null;
+        const layout = artifactLayout ? classicLayoutPaths(projectRoot, artifactLayout) : null;
+        const preserveOpenSpecRoot = layout !== null &&
+            (await realWorkingFileExists(path.join(layout.openSpecRoot, 'config.yaml')));
+        const splitDocsWorkingTrees = artifactLayout === 'docs' && preserveOpenSpecRoot;
+        if (artifactLayout) {
+            const legacyRootExists = await assertWorkingTreeAbsentOrRealDirectory(projectRoot, legacyOpenSpecRoot);
+            const docsRootExists = await assertWorkingTreeAbsentOrRealDirectory(projectRoot, docsOpenSpecRoot);
+            if (legacyRootExists && docsRootExists) {
+                throw new Error('Refusing to remove conflicting legacy and docs OpenSpec roots');
+            }
+            const alternateRootExists = artifactLayout === 'legacy' ? docsRootExists : legacyRootExists;
+            if (alternateRootExists) {
+                throw new Error('Refusing to remove an OpenSpec root that does not match project config');
+            }
+        }
+        const cometTree = cloneManagedWorkingTree(COMET_WORKING_TREE);
+        const docsTree = {
+            superpowers: cloneManagedWorkingTree(SUPERPOWERS_WORKING_TREE),
+        };
+        const legacyTree = cloneManagedWorkingTree(OPENSPEC_WORKING_TREE);
+        if (artifactLayout === 'docs' && !preserveOpenSpecRoot) {
+            mergeManagedWorkingTree(docsTree, ['openspec'], OPENSPEC_WORKING_TREE);
+        }
+        let separateNativeRoot = null;
+        if (nativeEnabled) {
+            if (!document?.native)
+                throw new Error('Native project config is incomplete');
+            const nativePaths = await nativeProjectPaths(projectRoot, document.native.artifact_root);
+            if (isInsideDirectory(docsDir, nativePaths.nativeRoot)) {
+                if (splitDocsWorkingTrees) {
+                    separateNativeRoot = nativePaths.nativeRoot;
+                }
+                else {
+                    mergeManagedWorkingTree(docsTree, path.relative(docsDir, nativePaths.nativeRoot).split(path.sep).filter(Boolean), NATIVE_WORKING_TREE);
+                }
+            }
+            else if (isInsideDirectory(cometDir, nativePaths.nativeRoot)) {
+                mergeManagedWorkingTree(cometTree, path.relative(cometDir, nativePaths.nativeRoot).split(path.sep).filter(Boolean), NATIVE_WORKING_TREE);
+            }
+            else if (artifactLayout === 'legacy' &&
+                isInsideDirectory(legacyOpenSpecRoot, nativePaths.nativeRoot)) {
+                mergeManagedWorkingTree(legacyTree, path.relative(legacyOpenSpecRoot, nativePaths.nativeRoot).split(path.sep).filter(Boolean), NATIVE_WORKING_TREE);
+            }
+            else {
+                separateNativeRoot = nativePaths.nativeRoot;
+            }
+        }
+        const candidates = splitDocsWorkingTrees
+            ? [[path.join(docsDir, 'superpowers'), SUPERPOWERS_WORKING_TREE, false]]
+            : [[docsDir, docsTree, false]];
+        if (artifactLayout === 'legacy' && !preserveOpenSpecRoot) {
+            candidates.push([layout.openSpecRoot, legacyTree, false]);
+        }
+        if (separateNativeRoot) {
+            candidates.push([separateNativeRoot, NATIVE_WORKING_TREE, false]);
+        }
+        candidates.push([cometDir, cometTree, true]);
+        plans = [];
+        for (const [directory, managedTree, countRemoval] of candidates) {
+            const inspected = await inspectManagedWorkingTree(projectRoot, directory, managedTree, countRemoval);
+            if (inspected)
+                plans.push(inspected);
+        }
+        await options.testHooks?.afterPlanInspection?.();
+        if (!workflowProjectConfigIdentityEquals(configIdentity, await readWorkflowProjectConfigIdentity(projectRoot))) {
+            throw new Error('Project config changed during uninstall planning');
+        }
+        for (const plan of plans) {
+            await validateManagedWorkingTree(projectRoot, plan);
+        }
+    }
+    catch {
+        return { removed: 0, failed: 1 };
+    }
+    try {
+        return await removeManagedWorkingTree(projectRoot, plans);
+    }
+    catch {
+        return { removed: 0, failed: 1 };
+    }
+}
+export { removeCometSkillsForPlatform, removeCometRulesForPlatform, removeCometHooksForPlatform, removeWorkingDirs, removeCometProjectInstructions, };
+//# sourceMappingURL=uninstall.js.map