@rpamis/comet 0.4.0-beta.3 → 0.4.0-beta.5

package/dist/domains/skill/platform-install.js

@@ -4,8 +4,10 @@ import { readFile, writeFile, lstat, unlink, symlink, rm, readdir } from 'fs/pro
 import { fileURLToPath } from 'url';
 import { parseDocument } from 'yaml';
 import { fileExists, readJson, copyFile, ensureDir } from '../../platform/fs/file-system.js';
-import { getPlatformSkillsDir } from '../../platform/install/platforms.js';
+import { getPlatformConfigDir, getPlatformSkillsDir, } from '../../platform/install/platforms.js';
 import { formatSupportedArtifactLanguages, resolveArtifactLanguage } from './languages.js';
+import { installCometProjectInstructions } from './project-instructions.js';
+import { readJsonObjectFile } from './json-object.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 function planSkillDirectoryCopy(files, destinationRoot) {
@@ -32,6 +34,25 @@ function getManagedSkillReplacementPaths(manifest) {
     }
     return allowed;
 }
+function getManagedSkillTopLevelEntries(manifest) {
+    const entries = new Set();
+    for (const skillPath of getManagedSkillPaths(manifest)) {
+        const [topLevel] = skillPath.split('/').filter(Boolean);
+        if (topLevel)
+            entries.add(topLevel);
+    }
+    return [...entries].sort();
+}
+function getManagedEntriesForTopLevel(managedEntries, topLevelEntry) {
+    const scopedEntries = new Set();
+    const prefix = `${topLevelEntry}/`;
+    for (const entry of managedEntries) {
+        if (entry.startsWith(prefix)) {
+            scopedEntries.add(entry.slice(prefix.length));
+        }
+    }
+    return scopedEntries;
+}
 async function collectDirectoryEntryPaths(root, current = root) {
     const entries = await readdir(current, { withFileTypes: true });
     const paths = [];
@@ -112,10 +133,41 @@ async function createSymlink(target, linkPath, managedEntries) {
     const type = process.platform === 'win32' ? 'junction' : 'dir';
     await symlink(target, linkPath, type);
 }
+async function lstatOrNull(filePath) {
+    try {
+        return await lstat(filePath);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+async function createSkillsSymlinks(targetRoot, linkRoot, managedEntries, topLevelEntries) {
+    const rootStat = await lstatOrNull(linkRoot);
+    if (!rootStat || rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+        await createSymlink(targetRoot, linkRoot, managedEntries);
+        return 0;
+    }
+    let failed = 0;
+    for (const topLevelEntry of topLevelEntries) {
+        const targetEntry = path.join(targetRoot, topLevelEntry);
+        const linkEntry = path.join(linkRoot, topLevelEntry);
+        const managedEntryScope = getManagedEntriesForTopLevel(managedEntries, topLevelEntry);
+        try {
+            await createSymlink(targetEntry, linkEntry, managedEntryScope);
+        }
+        catch (err) {
+            failed++;
+            console.error(`    Failed to create symlink ${linkEntry} -> ${targetEntry}: ${err.message}`);
+        }
+    }
+    return failed;
+}
 /**
  * Install skills using symlink mode:
  * 1. Copy skills to central store (.comet/skills/)
- * 2. Create symlink from platform dir to central store
+ * 2. Create symlinks from the platform skills dir to central store
  */
 async function installSkillsAsSymlink(baseDir, platform, overwrite, languageSkillsDir = 'skills', scope = 'project') {
     const centralDir = getCentralSkillsDir(baseDir, scope);
@@ -129,6 +181,7 @@ async function installSkillsAsSymlink(baseDir, platform, overwrite, languageSkil
         throw new Error(`Invalid manifest at ${manifestPath}: "skills" must be an array`);
     }
     const managedSkillReplacementPaths = getManagedSkillReplacementPaths(manifest);
+    const managedSkillTopLevelEntries = getManagedSkillTopLevelEntries(manifest);
     // Step 1: Copy skills to central store
     let copied = 0;
     let skippedCount = 0;
@@ -138,11 +191,11 @@ async function installSkillsAsSymlink(baseDir, platform, overwrite, languageSkil
         const sourceDir = isScript ? 'skills' : languageSkillsDir;
         const src = path.join(assetsDir, sourceDir, skillRelPath);
         const centralDest = path.join(centralDir, 'skills', skillRelPath);
-        if (!overwrite && (await fileExists(centralDest))) {
-            skippedCount++;
-            continue;
-        }
         try {
+            if (!overwrite && (await fileExists(centralDest))) {
+                skippedCount++;
+                continue;
+            }
             await copyFile(src, centralDest);
             copied++;
         }
@@ -151,11 +204,11 @@ async function installSkillsAsSymlink(baseDir, platform, overwrite, languageSkil
             console.error(`    Failed to copy ${skillRelPath} to central store: ${err.message}`);
         }
     }
-    // Step 2: Create symlink from platform dir to central store
+    // Step 2: Create symlinks from platform dir to central store
     const platformSkillsDir = path.join(baseDir, getPlatformSkillsDir(platform, scope), 'skills');
     const centralSkillsDir = path.join(centralDir, 'skills');
     try {
-        await createSymlink(centralSkillsDir, platformSkillsDir, managedSkillReplacementPaths);
+        failedCount += await createSkillsSymlinks(centralSkillsDir, platformSkillsDir, managedSkillReplacementPaths, managedSkillTopLevelEntries);
     }
     catch (err) {
         failedCount++;
@@ -166,12 +219,14 @@ async function installSkillsAsSymlink(baseDir, platform, overwrite, languageSkil
         const result = await createOpenCodeCommands(baseDir, platform, manifest.skills, overwrite, scope, languageSkillsDir);
         copied += result.copied;
         skippedCount += result.skipped;
+        failedCount += result.failed;
     }
     // Handle Pi platform command extension
     if (platform.id === 'pi') {
         const result = await createPiCommandExtension(baseDir, platform, manifest.skills, overwrite, scope);
         copied += result.copied;
         skippedCount += result.skipped;
+        failedCount += result.failed;
     }
     return { copied, skipped: skippedCount, failed: failedCount };
 }
@@ -196,11 +251,11 @@ async function copyCometSkillsForPlatform(baseDir, platform, overwrite, language
         const sourceDir = isScript ? 'skills' : languageSkillsDir;
         const src = path.join(assetsDir, sourceDir, skillRelPath);
         const dest = path.join(baseDir, getPlatformSkillsDir(platform, scope), 'skills', skillRelPath);
-        if (!overwrite && (await fileExists(dest))) {
-            skippedCount++;
-            continue;
-        }
         try {
+            if (!overwrite && (await fileExists(dest))) {
+                skippedCount++;
+                continue;
+            }
             await copyFile(src, dest);
             copied++;
         }
@@ -217,11 +272,13 @@ async function copyCometSkillsForPlatform(baseDir, platform, overwrite, language
         const result = await createOpenCodeCommands(baseDir, platform, manifest.skills, overwrite, scope, languageSkillsDir);
         copied += result.copied;
         skippedCount += result.skipped;
+        failedCount += result.failed;
     }
     if (platform.id === 'pi') {
         const result = await createPiCommandExtension(baseDir, platform, manifest.skills, overwrite, scope);
         copied += result.copied;
         skippedCount += result.skipped;
+        failedCount += result.failed;
     }
     return { copied, skipped: skippedCount, failed: failedCount };
 }
@@ -252,37 +309,46 @@ async function createPiCommandExtension(baseDir, platform, skillPaths, overwrite
     const platformBase = path.join(baseDir, getPlatformSkillsDir(platform, scope));
     const settingsPath = path.join(platformBase, 'settings.json');
     const extensionPath = path.join(platformBase, 'extensions', PI_COMMAND_EXTENSION_FILE);
-    let settings = {};
-    if (await fileExists(settingsPath)) {
-        try {
+    let copied = 0;
+    let skipped = 0;
+    let failed = 0;
+    try {
+        let settings = {};
+        if (await fileExists(settingsPath)) {
             const parsed = JSON.parse(await readFile(settingsPath, 'utf-8'));
             if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
                 throw new Error('expected a JSON object');
             }
             settings = parsed;
         }
-        catch (err) {
-            throw new Error(`Invalid Pi settings at ${settingsPath}: ${err.message}`, {
-                cause: err,
-            });
+        if (settings.enableSkillCommands !== true) {
+            settings.enableSkillCommands = true;
+            await ensureDir(path.dirname(settingsPath));
+            await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+            copied++;
         }
     }
-    let copied = 0;
-    let skipped = 0;
-    if (settings.enableSkillCommands !== true) {
-        settings.enableSkillCommands = true;
-        await ensureDir(path.dirname(settingsPath));
-        await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-        copied++;
+    catch (err) {
+        failed++;
+        console.error(`    Failed to update Pi settings at ${settingsPath}: ${err.message}`);
+    }
+    if (failed > 0)
+        return { copied, skipped, failed };
+    try {
+        if (!overwrite && (await fileExists(extensionPath))) {
+            skipped++;
+        }
+        else {
+            await ensureDir(path.dirname(extensionPath));
+            await writeFile(extensionPath, renderPiCommandExtension(getTopLevelSkillNames(skillPaths)), 'utf-8');
+            copied++;
+        }
     }
-    if (!overwrite && (await fileExists(extensionPath))) {
-        skipped++;
-        return { copied, skipped };
+    catch (err) {
+        failed++;
+        console.error(`    Failed to write Pi command extension at ${extensionPath}: ${err.message}`);
     }
-    await ensureDir(path.dirname(extensionPath));
-    await writeFile(extensionPath, renderPiCommandExtension(getTopLevelSkillNames(skillPaths)), 'utf-8');
-    copied++;
-    return { copied, skipped };
+    return { copied, skipped, failed };
 }
 function stripFrontmatter(content) {
     if (!content.startsWith('---\n') && !content.startsWith('---\r\n')) {
@@ -297,6 +363,7 @@ function stripFrontmatter(content) {
 async function createOpenCodeCommands(baseDir, platform, skillPaths, overwrite, scope, languageSkillsDir) {
     let copied = 0;
     let skipped = 0;
+    let failed = 0;
     const assetsDir = getAssetsDir();
     const commandsDir = path.join(baseDir, getPlatformSkillsDir(platform, scope), 'commands');
     for (const skillPath of skillPaths) {
@@ -305,17 +372,18 @@ async function createOpenCodeCommands(baseDir, platform, skillPaths, overwrite,
             continue;
         const skillName = parts[0];
         const dest = path.join(commandsDir, `${skillName}.md`);
-        if (!overwrite && (await fileExists(dest))) {
-            skipped++;
-            continue;
-        }
-        await ensureDir(path.dirname(dest));
-        let skillSourcePath = path.join(assetsDir, languageSkillsDir, skillPath);
-        if (!(await fileExists(skillSourcePath))) {
-            skillSourcePath = path.join(assetsDir, 'skills', skillPath);
-        }
-        const skillBody = stripFrontmatter(await readFile(skillSourcePath, 'utf-8'));
-        const content = `${OPENCODE_COMMAND_HEADER.replace('{skillName}', skillName)}
+        try {
+            if (!overwrite && (await fileExists(dest))) {
+                skipped++;
+                continue;
+            }
+            await ensureDir(path.dirname(dest));
+            let skillSourcePath = path.join(assetsDir, languageSkillsDir, skillPath);
+            if (!(await fileExists(skillSourcePath))) {
+                skillSourcePath = path.join(assetsDir, 'skills', skillPath);
+            }
+            const skillBody = stripFrontmatter(await readFile(skillSourcePath, 'utf-8'));
+            const content = `${OPENCODE_COMMAND_HEADER.replace('{skillName}', skillName)}
 Equivalent Comet skill: \`${skillName}\`
 Command name: \`/${skillName}\`
 
@@ -327,10 +395,15 @@ $ARGUMENTS
 
 ${skillBody}
 `;
-        await writeFile(dest, content, 'utf-8');
-        copied++;
+            await writeFile(dest, content, 'utf-8');
+            copied++;
+        }
+        catch (err) {
+            failed++;
+            console.error(`    Failed to create OpenCode command ${dest}: ${err.message}`);
+        }
     }
-    return { copied, skipped };
+    return { copied, skipped, failed };
 }
 async function readManifest() {
     const assetsDir = getAssetsDir();
@@ -377,12 +450,12 @@ function selectRulePathsForLanguage(rulePaths, languageId) {
 }
 async function copyCometRulesForPlatform(baseDir, platform, overwrite, languageId, scope = 'project') {
     if (!platform.rulesDir || !platform.rulesFormat) {
-        return { copied: 0, skipped: 0 };
+        return { copied: 0, skipped: 0, failed: 0 };
     }
     const manifest = await readManifest();
     const rulePaths = selectRulePathsForLanguage(manifest.rules ?? [], languageId);
     if (!rulePaths || rulePaths.length === 0) {
-        return { copied: 0, skipped: 0 };
+        return { copied: 0, skipped: 0, failed: 0 };
     }
     const assetsDir = getAssetsDir();
     // Support platforms whose rules live outside the skills config dir
@@ -394,22 +467,24 @@ async function copyCometRulesForPlatform(baseDir, platform, overwrite, languageI
         : path.join(baseDir, getPlatformSkillsDir(platform, scope));
     let copied = 0;
     let skippedCount = 0;
+    let failed = 0;
     for (const ruleRelPath of rulePaths) {
         const src = path.join(assetsDir, 'skills', ruleRelPath);
-        if (!(await fileExists(src))) {
-            console.error(`    Rule source not found: ${ruleRelPath}`);
-            continue;
-        }
-        // Normalize the `.en` infix away so the installed file name is the same
-        // regardless of which language variant was selected.
-        const ruleFileName = toRuleBaseName(path.basename(ruleRelPath));
-        const rulesDestDir = path.join(rulesBase, platform.rulesDir);
-        const dest = computeRuleDestPath(rulesDestDir, ruleFileName, platform.rulesFormat);
-        if (!overwrite && (await fileExists(dest))) {
-            skippedCount++;
-            continue;
-        }
         try {
+            if (!(await fileExists(src))) {
+                console.error(`    Rule source not found: ${ruleRelPath}`);
+                failed++;
+                continue;
+            }
+            // Normalize the `.en` infix away so the installed file name is the same
+            // regardless of which language variant was selected.
+            const ruleFileName = toRuleBaseName(path.basename(ruleRelPath));
+            const rulesDestDir = path.join(rulesBase, platform.rulesDir);
+            const dest = computeRuleDestPath(rulesDestDir, ruleFileName, platform.rulesFormat);
+            if (!overwrite && (await fileExists(dest))) {
+                skippedCount++;
+                continue;
+            }
             const content = await readFile(src, 'utf-8');
             await ensureDir(path.dirname(dest));
             const formatted = formatRuleContent(content, ruleFileName, platform.rulesFormat);
@@ -418,9 +493,10 @@ async function copyCometRulesForPlatform(baseDir, platform, overwrite, languageI
         }
         catch (err) {
             console.error(`    Failed to copy rule ${ruleRelPath}: ${err.message}`);
+            failed++;
         }
     }
-    return { copied, skipped: skippedCount };
+    return { copied, skipped: skippedCount, failed };
 }
 function computeRuleDestPath(rulesDestDir, ruleFileName, rulesFormat) {
     if (rulesFormat === 'mdc') {
@@ -457,47 +533,68 @@ ${content}`;
 /**
  * Install Comet hooks for platforms that support them.
  * Supports multiple hook formats:
- *   'claude-code' — settings.local.json with PreToolUse array (Claude Code, Codex, Amazon Q)
+ *   'claude-code' — Claude-shaped JSON with PreToolUse array; defaults to settings.local.json,
+ *                   with platform metadata able to override the filename
  *   'qwen' — settings.json with PreToolUse/hooks array (Qwen Code)
  *   'qoder' — settings.json with PreToolUse/hooks array (Qoder)
+ *   'codebuddy' — settings.json with PreToolUse/hooks array (CodeBuddy Code)
  *   'gemini' — settings.json with hooks.BeforeTool array (Gemini CLI)
  *   'windsurf' — hooks.json with pre_write_code array
  *   'copilot' — hooks/*.json with preToolUse
  *   'kiro' — hooks/*.kiro.hook JSON files
  */
 async function installCometHooksForPlatform(baseDir, platform, scope = 'project') {
-    if (!platform.supportsHooks || !platform.hookFormat) {
-        return { installed: false, reason: 'platform does not support hooks' };
+    if (!platform.supportsHooks) {
+        return { status: 'skipped', reason: 'platform does not support hooks' };
     }
-    const manifest = await readManifest();
-    const hooksConfig = manifest.hooks;
-    if (!hooksConfig || Object.keys(hooksConfig).length === 0) {
-        return { installed: false, reason: 'no hooks defined in manifest' };
+    if (!platform.hookFormat) {
+        return {
+            status: 'failed',
+            reason: 'hook-capable platform does not declare a hook format',
+        };
     }
-    const hookFormat = platform.hookFormat;
-    const skillsDir = getPlatformSkillsDir(platform, scope);
-    const platformBase = path.join(baseDir, skillsDir);
     try {
+        const manifest = await readManifest();
+        const hooksConfig = manifest.hooks;
+        if (!hooksConfig || Object.keys(hooksConfig).length === 0) {
+            return { status: 'skipped', reason: 'no hooks defined in manifest' };
+        }
+        const hookFormat = platform.hookFormat;
+        const skillsDir = getPlatformSkillsDir(platform, scope);
+        const platformBase = path.join(baseDir, getPlatformConfigDir(platform, scope));
         switch (hookFormat) {
-            case 'claude-code':
-                return installClaudeCodeHooks(baseDir, platformBase, skillsDir, hooksConfig);
+            case 'claude-code': {
+                const result = await installClaudeCodeHooks(baseDir, platformBase, skillsDir, hooksConfig, platform.hookConfigFile ?? 'settings.local.json', platform.name);
+                if (result.status === 'installed') {
+                    for (const legacyFile of platform.legacyHookConfigFiles ?? []) {
+                        try {
+                            await removeManagedHooksFromJsonFile(path.join(platformBase, legacyFile), Object.keys(hooksConfig));
+                        }
+                        catch {
+                            // Historical Hook cleanup is best-effort after canonical install succeeds.
+                        }
+                    }
+                }
+                return result;
+            }
             case 'qwen':
             case 'qoder':
-                return installQwenStyleHooks(baseDir, platformBase, skillsDir, hooksConfig, hookFormat);
+            case 'codebuddy':
+                return await installQwenStyleHooks(baseDir, platformBase, skillsDir, hooksConfig, platform.name);
             case 'gemini':
-                return installGeminiHooks(baseDir, platformBase, skillsDir, hooksConfig);
+                return await installGeminiHooks(baseDir, platformBase, skillsDir, hooksConfig, platform.name);
             case 'windsurf':
-                return installWindsurfHooks(baseDir, platformBase, skillsDir, hooksConfig);
+                return await installWindsurfHooks(baseDir, platformBase, skillsDir, hooksConfig, platform.name);
             case 'copilot':
-                return installCopilotHooks(baseDir, platformBase, skillsDir, hooksConfig);
+                return await installCopilotHooks(baseDir, platformBase, skillsDir, hooksConfig);
             case 'kiro':
-                return installKiroHooks(baseDir, platformBase, skillsDir, hooksConfig);
+                return await installKiroHooks(baseDir, platformBase, skillsDir, hooksConfig);
             default:
-                return { installed: false, reason: `unsupported hook format: ${hookFormat}` };
+                return { status: 'failed', reason: `unsupported hook format: ${hookFormat}` };
         }
     }
     catch (err) {
-        return { installed: false, reason: err.message };
+        return { status: 'failed', reason: err.message };
     }
 }
 function quoteCommandArg(value) {
@@ -509,34 +606,96 @@ function buildHookCommand(baseDir, skillsDir, scriptRelPath) {
     const scriptPath = path.join(projectRoot, skillsDir, 'skills', ...scriptRelPath.split('/'));
     return `node ${quoteCommandArg(scriptPath)} --project-root ${quoteCommandArg(projectRoot)}`;
 }
+function parseCommandTokens(command) {
+    const tokens = [];
+    let current = '';
+    let quote;
+    let tokenStarted = false;
+    let quoteClosed = false;
+    for (let index = 0; index < command.length; index++) {
+        const character = command[index];
+        if (quote) {
+            if (character === quote) {
+                quote = undefined;
+                quoteClosed = true;
+            }
+            else if (character === '\\' && command[index + 1] === quote) {
+                current += quote;
+                index++;
+            }
+            else {
+                current += character;
+            }
+            continue;
+        }
+        if (character === '\r' || character === '\n' || ';|&<>`'.includes(character)) {
+            return undefined;
+        }
+        if (/\s/u.test(character)) {
+            if (tokenStarted) {
+                tokens.push(current);
+                current = '';
+                tokenStarted = false;
+                quoteClosed = false;
+            }
+            continue;
+        }
+        if (quoteClosed)
+            return undefined;
+        if (character === '"' || character === "'") {
+            if (tokenStarted)
+                return undefined;
+            quote = character;
+            tokenStarted = true;
+            continue;
+        }
+        current += character;
+        tokenStarted = true;
+    }
+    if (quote)
+        return undefined;
+    if (tokenStarted)
+        tokens.push(current);
+    return tokens;
+}
 function isManagedHookCommand(command, scriptRelPaths) {
     if (typeof command !== 'string')
         return false;
     // Match both the current `node .../comet-hook-guard.mjs` form and the legacy
     // `bash .../comet-hook-guard.sh` form so uninstall also cleans up hooks
     // written by older Comet releases. Compare basenames without extension.
-    const commandPath = command
-        .trim()
-        .match(/^(?:node|bash|sh)\s+["']?([^"'\s]+)["']?(?:\s|$)/)?.[1]
-        ?.replace(/\\/g, '/');
-    if (!commandPath)
+    const tokens = parseCommandTokens(command.trim());
+    if (!tokens || tokens.length < 2 || !['node', 'bash', 'sh'].includes(tokens[0]))
         return false;
+    const commandPath = tokens[1].replace(/\\/g, '/');
     const normalize = (value) => value.replace(/\.(?:sh|mjs)$/u, '');
     return scriptRelPaths.some((scriptRelPath) => normalize(commandPath).endsWith(`/skills/${normalize(scriptRelPath.replace(/\\/g, '/'))}`));
 }
 function mergeHookGroups(existingGroups, newGroups, scriptRelPaths) {
-    const mergedGroups = existingGroups.flatMap((group) => {
-        if (!Array.isArray(group.hooks))
-            return [group];
-        const hooks = group.hooks.filter((hook) => !isManagedHookCommand(hook.command, scriptRelPaths));
-        if (hooks.length === 0 && group.hooks.length > 0)
-            return [];
-        return [{ ...group, hooks }];
+    const mergedGroups = existingGroups.map((group) => {
+        if (!group || typeof group !== 'object' || Array.isArray(group))
+            return group;
+        const record = group;
+        if (!Array.isArray(record.hooks))
+            return record;
+        const hooks = record.hooks.filter((hook) => {
+            const command = hook && typeof hook === 'object' ? hook.command : undefined;
+            return !isManagedHookCommand(command, scriptRelPaths);
+        });
+        return { ...record, hooks };
     });
     for (const newGroup of newGroups) {
-        const existingGroup = mergedGroups.find((group) => group.matcher === newGroup.matcher && Array.isArray(group.hooks));
-        if (existingGroup) {
-            existingGroup.hooks = [...existingGroup.hooks, ...newGroup.hooks];
+        const existingGroupIndex = mergedGroups.findIndex((group) => Boolean(group) &&
+            typeof group === 'object' &&
+            !Array.isArray(group) &&
+            group.matcher === newGroup.matcher &&
+            Array.isArray(group.hooks));
+        if (existingGroupIndex >= 0) {
+            const existingGroup = mergedGroups[existingGroupIndex];
+            mergedGroups[existingGroupIndex] = {
+                ...existingGroup,
+                hooks: [...existingGroup.hooks, ...newGroup.hooks],
+            };
         }
         else {
             mergedGroups.push(newGroup);
@@ -552,12 +711,77 @@ function mergeHookGroups(existingGroups, newGroups, scriptRelPaths) {
 function asHookGroup(value) {
     return Array.isArray(value) ? value : [];
 }
+async function removeManagedHooksFromJsonFile(settingsPath, scriptRelPaths) {
+    if (!(await fileExists(settingsPath)))
+        return { removed: 0, failed: 0 };
+    let source;
+    try {
+        source = await readFile(settingsPath, 'utf-8');
+    }
+    catch {
+        return { removed: 0, failed: 1 };
+    }
+    let settings;
+    try {
+        const parsed = JSON.parse(source);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return { removed: 0, failed: 1 };
+        }
+        settings = parsed;
+    }
+    catch {
+        return { removed: 0, failed: 1 };
+    }
+    const existingHooks = settings.hooks;
+    const existingPreToolUse = existingHooks?.PreToolUse;
+    if (!existingHooks || !Array.isArray(existingPreToolUse)) {
+        return { removed: 0, failed: 0 };
+    }
+    let removed = 0;
+    const filtered = existingPreToolUse.map((group) => {
+        if (!group || typeof group !== 'object')
+            return group;
+        const record = group;
+        if (!Array.isArray(record.hooks))
+            return record;
+        const handlers = record.hooks.filter((handler) => {
+            const command = handler && typeof handler === 'object'
+                ? handler.command
+                : undefined;
+            const managed = isManagedHookCommand(command, scriptRelPaths);
+            if (managed)
+                removed++;
+            return !managed;
+        });
+        return { ...record, hooks: handlers };
+    });
+    if (removed === 0)
+        return { removed: 0, failed: 0 };
+    existingHooks.PreToolUse = filtered;
+    try {
+        await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+    }
+    catch {
+        return { removed: 0, failed: 1 };
+    }
+    return { removed, failed: 0 };
+}
+async function readSettingsJsonObject(settingsPath, platformName) {
+    const result = await readJsonObjectFile(settingsPath);
+    if (result.status === 'missing')
+        return {};
+    if (result.status === 'present')
+        return result.value;
+    throw new Error(`Invalid ${platformName} settings at ${settingsPath}: ${result.error.message}`, {
+        cause: result.error,
+    });
+}
 /**
- * Claude Code, Codex, Amazon Q format:
- * Writes to settings.local.json with { hooks: { PreToolUse: [...] } }
+ * Claude-shaped JSON format used by Claude Code, Codex, and Amazon Q.
+ * Defaults to settings.local.json; platform metadata may override the filename.
  */
-async function installClaudeCodeHooks(baseDir, platformBase, skillsDir, hooksConfig) {
-    const settingsPath = path.join(platformBase, 'settings.local.json');
+async function installClaudeCodeHooks(baseDir, platformBase, skillsDir, hooksConfig, configFile, platformName) {
+    const settingsPath = path.join(platformBase, configFile);
     // Group by matcher so hooks sharing the same matcher are merged
     const matcherGroups = {};
     for (const [scriptRelPath, config] of Object.entries(hooksConfig)) {
@@ -568,28 +792,20 @@ async function installClaudeCodeHooks(baseDir, platformBase, skillsDir, hooksCon
         matcherGroups[config.matcher].push({ type: 'command', command });
     }
     const newEntries = Object.entries(matcherGroups).map(([matcher, hooks]) => ({ matcher, hooks }));
-    let settings = {};
-    if (await fileExists(settingsPath)) {
-        try {
-            settings = JSON.parse(await readFile(settingsPath, 'utf-8'));
-        }
-        catch {
-            settings = {};
-        }
-    }
+    const settings = await readSettingsJsonObject(settingsPath, platformName);
     const existingHooks = settings.hooks ?? {};
     const existingPreToolUse = asHookGroup(existingHooks.PreToolUse);
     const merged = mergeHookGroups(existingPreToolUse, newEntries, Object.keys(hooksConfig));
     settings.hooks = { ...existingHooks, PreToolUse: merged };
     await ensureDir(path.dirname(settingsPath));
     await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    return { installed: true };
+    return { status: 'installed' };
 }
 /**
- * Qwen Code / Qoder format:
+ * Qwen Code / Qoder / CodeBuddy format:
  * Writes to settings.json with { hooks: { PreToolUse: [{ matcher, hooks: [{ type, command }] }] } }
  */
-async function installQwenStyleHooks(baseDir, platformBase, skillsDir, hooksConfig, _hookFormat) {
+async function installQwenStyleHooks(baseDir, platformBase, skillsDir, hooksConfig, platformName) {
     const settingsPath = path.join(platformBase, 'settings.json');
     // Group by matcher
     const matcherGroups = {};
@@ -607,28 +823,20 @@ async function installQwenStyleHooks(baseDir, platformBase, skillsDir, hooksConf
         matcher,
         hooks,
     }));
-    let settings = {};
-    if (await fileExists(settingsPath)) {
-        try {
-            settings = JSON.parse(await readFile(settingsPath, 'utf-8'));
-        }
-        catch {
-            settings = {};
-        }
-    }
+    const settings = await readSettingsJsonObject(settingsPath, platformName);
     const existingHooks = settings.hooks ?? {};
     const existingPreToolUse = asHookGroup(existingHooks.PreToolUse);
     const merged = mergeHookGroups(existingPreToolUse, preToolUseEntries, Object.keys(hooksConfig));
     settings.hooks = { ...existingHooks, PreToolUse: merged };
     await ensureDir(path.dirname(settingsPath));
     await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    return { installed: true };
+    return { status: 'installed' };
 }
 /**
  * Gemini CLI format:
  * Writes to .gemini/settings.json with { hooks: { BeforeTool: [{ matcher, hooks: [{ type, command }] }] } }
  */
-async function installGeminiHooks(baseDir, platformBase, skillsDir, hooksConfig) {
+async function installGeminiHooks(baseDir, platformBase, skillsDir, hooksConfig, platformName) {
     const settingsPath = path.join(platformBase, 'settings.json');
     const entries = [];
     for (const [scriptRelPath, config] of Object.entries(hooksConfig)) {
@@ -643,28 +851,20 @@ async function installGeminiHooks(baseDir, platformBase, skillsDir, hooksConfig)
             ],
         });
     }
-    let settings = {};
-    if (await fileExists(settingsPath)) {
-        try {
-            settings = JSON.parse(await readFile(settingsPath, 'utf-8'));
-        }
-        catch {
-            settings = {};
-        }
-    }
+    const settings = await readSettingsJsonObject(settingsPath, platformName);
     const existingHooks = settings.hooks ?? {};
     const existingBeforeTool = asHookGroup(existingHooks.BeforeTool);
     const merged = mergeHookGroups(existingBeforeTool, entries, Object.keys(hooksConfig));
     settings.hooks = { ...existingHooks, BeforeTool: merged };
     await ensureDir(path.dirname(settingsPath));
     await writeFile(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
-    return { installed: true };
+    return { status: 'installed' };
 }
 /**
  * Windsurf format:
  * Writes to .windsurf/hooks.json with { hooks: { pre_write_code: [{ command }] } }
  */
-async function installWindsurfHooks(baseDir, platformBase, skillsDir, hooksConfig) {
+async function installWindsurfHooks(baseDir, platformBase, skillsDir, hooksConfig, platformName) {
     const hooksPath = path.join(platformBase, 'hooks.json');
     const entries = [];
     for (const [scriptRelPath] of Object.entries(hooksConfig)) {
@@ -673,23 +873,18 @@ async function installWindsurfHooks(baseDir, platformBase, skillsDir, hooksConfi
             show_output: true,
         });
     }
-    let hooksFile = {};
-    if (await fileExists(hooksPath)) {
-        try {
-            hooksFile = JSON.parse(await readFile(hooksPath, 'utf-8'));
-        }
-        catch {
-            hooksFile = {};
-        }
-    }
+    const hooksFile = await readSettingsJsonObject(hooksPath, platformName);
     const existingHooks = hooksFile.hooks ?? {};
     const existingPreWrite = asHookGroup(existingHooks.pre_write_code);
-    const merged = existingPreWrite.filter((entry) => !isManagedHookCommand(entry.command, Object.keys(hooksConfig)));
+    const merged = existingPreWrite.filter((entry) => {
+        const command = entry && typeof entry === 'object' ? entry.command : undefined;
+        return !isManagedHookCommand(command, Object.keys(hooksConfig));
+    });
     merged.push(...entries);
     hooksFile.hooks = { ...existingHooks, pre_write_code: merged };
     await ensureDir(path.dirname(hooksPath));
     await writeFile(hooksPath, JSON.stringify(hooksFile, null, 2) + '\n', 'utf-8');
-    return { installed: true };
+    return { status: 'installed' };
 }
 /**
  * GitHub Copilot format:
@@ -712,7 +907,7 @@ async function installCopilotHooks(baseDir, platformBase, skillsDir, hooksConfig
     };
     await ensureDir(hooksDir);
     await writeFile(hookFilePath, JSON.stringify(hookConfig, null, 2) + '\n', 'utf-8');
-    return { installed: true };
+    return { status: 'installed' };
 }
 /**
  * Kiro format:
@@ -742,7 +937,7 @@ async function installKiroHooks(baseDir, platformBase, skillsDir, hooksConfig) {
         await ensureDir(hooksDir);
         await writeFile(hookFilePath, JSON.stringify(hookConfig, null, 2) + '\n', 'utf-8');
     }
-    return { installed: true };
+    return { status: 'installed' };
 }
 function managedConfigFields(language = 'en') {
     const artifactLanguage = resolveArtifactLanguage(language);
@@ -780,13 +975,20 @@ function parseProjectConfigOverrides(content) {
     }
     return out;
 }
-function renderProjectConfig(existing, language = 'en') {
+// `language` is null when the caller has no definitive language selection to assert (e.g.
+// multiple platforms in the same scope disagree and no --language flag was given) — in that
+// case the existing config's language is preserved, falling back to 'en' only when absent.
+// A non-null language always overwrites the managed `language` field: init/update pass it
+// specifically to persist the language the user just selected/installed.
+function renderProjectConfig(existing, language = null) {
+    const resolvedLanguage = language ?? existing.language ?? 'en';
     const lines = [];
-    const fields = getManagedConfigFields(language);
+    const fields = getManagedConfigFields(resolvedLanguage);
     const managed = new Set(fields.map((f) => f.key));
     for (const f of fields) {
         lines.push(f.comment);
-        lines.push(`${f.key}: ${existing[f.key] ?? f.def}`);
+        const value = f.key === 'language' ? resolvedLanguage : (existing[f.key] ?? f.def);
+        lines.push(`${f.key}: ${value}`);
     }
     for (const [k, v] of Object.entries(existing)) {
         if (!managed.has(k))
@@ -795,7 +997,7 @@ function renderProjectConfig(existing, language = 'en') {
     lines.push('');
     return lines.join('\n');
 }
-async function mergeProjectConfig(projectPath, language = 'en') {
+async function mergeProjectConfig(projectPath, language = null) {
     const configPath = path.join(projectPath, '.comet', 'config.yaml');
     let existing = {};
     if (await fileExists(configPath)) {
@@ -814,6 +1016,7 @@ async function createWorkingDirs(projectPath, language = 'en') {
         await ensureDir(dir);
     }
     await mergeProjectConfig(projectPath, language);
+    await installCometProjectInstructions(projectPath, language === 'zh-CN' ? 'zh' : 'en');
 }
-export { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, readManifest, getManagedSkillPaths, getManifestSkills, getUserFacingSkillNames, createWorkingDirs, getAssetsDir, computeRuleDestPath, formatRuleContent, isManagedHookCommand, planSkillDirectoryCopy, mergeProjectConfig, parseProjectConfigOverrides, renderProjectConfig, getCentralSkillsDir, installSkillsAsSymlink, };
+export { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, readManifest, getManagedSkillPaths, getManifestSkills, getUserFacingSkillNames, createWorkingDirs, getAssetsDir, computeRuleDestPath, formatRuleContent, isManagedHookCommand, buildHookCommand, removeManagedHooksFromJsonFile, planSkillDirectoryCopy, mergeProjectConfig, parseProjectConfigOverrides, renderProjectConfig, getCentralSkillsDir, installSkillsAsSymlink, };
 //# sourceMappingURL=platform-install.js.map