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

package/dist/app/commands/update.js

@@ -4,36 +4,78 @@ import { promises as fs } from 'fs';
 import { fileURLToPath } from 'url';
 import { spawn } from 'child_process';
 import { select } from '@inquirer/prompts';
-import { fileExists, readDir, readJson } from '../../platform/fs/file-system.js';
+import { fileExists, readJson } from '../../platform/fs/file-system.js';
 import { getBaseDir } from '../../platform/install/detect.js';
 import { copyCometSkillsForPlatform, copyCometRulesForPlatform, installCometHooksForPlatform, getManifestSkills, mergeProjectConfig, } from '../../domains/skill/platform-install.js';
-import { PLATFORMS, getPlatformSkillsDir, } from '../../platform/install/platforms.js';
+import { removeLegacyCometSkillsForPlatform } from '../../domains/skill/uninstall.js';
+import { installCometProjectInstructions } from '../../domains/skill/project-instructions.js';
+import { LANGUAGES } from '../../domains/skill/languages.js';
+import { getPlatformSkillsDir, getPlatformSkillsDirs, } from '../../platform/install/platforms.js';
+import { resolveCanonicalSkillRootOwners } from '../../platform/install/skill-root-owner.js';
+import { listProjectRegistryEntries, removeProjectInstallation, upsertProjectInstallation, } from '../../platform/install/project-registry.js';
 import { hasCodegraphProjectIndex, installCodegraph, } from '../../domains/integrations/codegraph.js';
 import { printVersionInfo } from '../../platform/version/version.js';
 import { t } from './i18n.js';
+import { assertProjectScopeOptions, resolveProjectScopeMode } from './project-scope-selection.js';
 const PACKAGE_NAME = '@rpamis/comet';
 const OFFICIAL_REGISTRY = 'https://registry.npmjs.org';
+function createNpmUpdateFailure(scope) {
+    const error = new Error(`npm package update failed (${scope} scope)`);
+    error.npmScope = scope;
+    return error;
+}
+function isGlobalNpmUpdateFailure(error) {
+    return error?.npmScope === 'global';
+}
 function resolveTargetLanguage(language, fallback) {
     return (language ?? fallback) === 'zh' ? 'zh' : 'en';
 }
 function languageToSkillsDir(languageId) {
     return languageId === 'zh' ? 'skills-zh' : 'skills';
 }
+function languageToArtifactLanguage(languageId) {
+    return LANGUAGES.find((entry) => entry.id === languageId).artifactLanguage;
+}
 function getScopedBaseDir(scope, projectPath, globalBaseDir = os.homedir()) {
     return scope === 'global' ? globalBaseDir : projectPath;
 }
 function getInstalledCometSkillsDirs(baseDir, platform, scope = 'project') {
-    const dirs = [path.join(baseDir, getPlatformSkillsDir(platform, scope), 'skills')];
-    if (scope === 'global' && platform.id === 'pi') {
-        dirs.push(path.join(baseDir, platform.skillsDir, 'skills'));
+    const skillsDirs = [
+        ...getPlatformSkillsDirs(platform, scope),
+        ...(scope === 'global' && platform.id === 'pi' ? [platform.skillsDir] : []),
+    ];
+    return [...new Set(skillsDirs)].map((skillsDir) => path.join(baseDir, skillsDir, 'skills'));
+}
+function isMissingInspectionError(error) {
+    const code = error?.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}
+async function targetPathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (isMissingInspectionError(error))
+            return false;
+        throw error;
+    }
+}
+async function readTargetDir(dirPath) {
+    try {
+        return await fs.readdir(dirPath);
+    }
+    catch (error) {
+        if (isMissingInspectionError(error))
+            return [];
+        throw error;
     }
-    return [...new Set(dirs)];
 }
 async function hasLocalCometSkills(baseDir, platform, scope) {
     for (const skillsDir of getInstalledCometSkillsDirs(baseDir, platform, scope)) {
-        if (!(await fileExists(skillsDir)))
+        if (!(await targetPathExists(skillsDir)))
             continue;
-        const entries = await readDir(skillsDir);
+        const entries = await readTargetDir(skillsDir);
         if (entries.some((entry) => entry.startsWith('comet')))
             return true;
     }
@@ -41,20 +83,21 @@ async function hasLocalCometSkills(baseDir, platform, scope) {
 }
 async function detectInstalledCometLanguage(baseDir, platform, scope = 'project') {
     for (const skillsDir of getInstalledCometSkillsDirs(baseDir, platform, scope)) {
-        if (!(await fileExists(skillsDir)))
+        if (!(await targetPathExists(skillsDir)))
             continue;
-        const entries = (await readDir(skillsDir)).filter((entry) => entry.startsWith('comet'));
+        const entries = (await readTargetDir(skillsDir)).filter((entry) => entry.startsWith('comet'));
         for (const entry of entries) {
             const skillPath = path.join(skillsDir, entry, 'SKILL.md');
-            if (!(await fileExists(skillPath)))
+            if (!(await targetPathExists(skillPath)))
                 continue;
             try {
                 const content = await fs.readFile(skillPath, 'utf-8');
                 if (/[㐀-鿿]/u.test(content))
                     return 'zh';
             }
-            catch {
-                // Fall through to the default English asset set if the file cannot be read.
+            catch (error) {
+                if (!isMissingInspectionError(error))
+                    throw error;
             }
         }
     }
@@ -65,7 +108,10 @@ async function detectInstalledCometTargets(projectPath, options = {}) {
     const targets = [];
     for (const scope of scopes) {
         const baseDir = getScopedBaseDir(scope, projectPath, options.globalBaseDir);
-        for (const platform of PLATFORMS) {
+        const owners = await resolveCanonicalSkillRootOwners(baseDir, scope, {
+            respectDetectionPaths: options.respectDetectionPaths,
+        });
+        for (const { platform } of owners) {
             if (!(await hasLocalCometSkills(baseDir, platform, scope)))
                 continue;
             targets.push({
@@ -107,7 +153,7 @@ function formatNpmUpdateCommand(scope) {
 function formatSkillUpdateCommand(scope, platform, languageSkillsDir, installMode = 'copy') {
     const destPrefix = scope === 'global' ? '~/' : '';
     if (installMode === 'symlink') {
-        return `symlink .comet/skills/ -> ${destPrefix}${getPlatformSkillsDir(platform, scope)}/skills/ (${scope})`;
+        return `symlink via .comet/skills/ in ${destPrefix}${getPlatformSkillsDir(platform, scope)}/skills/ (${scope})`;
     }
     return `copy assets/${languageSkillsDir} -> ${destPrefix}${getPlatformSkillsDir(platform, scope)}/skills/ (${scope})`;
 }
@@ -161,18 +207,130 @@ async function promptCodegraphInstall(lang) {
         ],
     });
 }
-export async function updateCommand(targetPath, options = {}) {
-    const projectPath = path.resolve(targetPath);
-    const log = options.json ? () => undefined : console.log;
-    const lang = options.language ?? 'en';
-    log(`\n  ${t(lang, 'updateTitle')}`);
-    if (!options.json) {
-        await printVersionInfo(log);
+function currentProjectJson(result) {
+    return {
+        status: hasComponentFailures(result) ? 'incomplete' : 'complete',
+        npm: result.npm,
+        skills: {
+            totalCopied: result.skills.totalCopied,
+            totalFailed: result.skills.totalFailed,
+            cleanupFailed: result.skills.cleanupFailed,
+            installMode: result.skills.installMode,
+            targets: result.skills.targets,
+        },
+        rules: result.rules,
+        hooks: result.hooks,
+        projectInstructions: result.projectInstructions,
+        codegraph: result.codegraph,
+    };
+}
+function hasComponentFailures(result) {
+    return (result.skills.totalFailed > 0 ||
+        result.skills.cleanupFailed > 0 ||
+        result.rules.totalFailed > 0 ||
+        result.hooks.totalFailed > 0);
+}
+function componentFailureReason(result) {
+    const reasons = [];
+    if (result.skills.totalFailed > 0) {
+        reasons.push(`Skill update failed (${result.skills.totalFailed})`);
     }
-    log('');
-    const packageScope = options.scope ?? (await detectCometPackageScope(projectPath));
+    if (result.rules.totalFailed > 0) {
+        reasons.push(`Rule update failed (${result.rules.totalFailed})`);
+    }
+    if (result.hooks.totalFailed > 0) {
+        reasons.push(`Hook update failed (${result.hooks.totalFailed})`);
+    }
+    if (result.skills.cleanupFailed > 0) {
+        reasons.push(`legacy Skill cleanup failed (${result.skills.cleanupFailed})`);
+    }
+    return reasons.join('; ');
+}
+function collectComponentFailures(result) {
+    const skillFailures = result.skills.targets.flatMap((target) => {
+        const failed = target.failed + target.cleanupFailed;
+        if (failed === 0 || !target.reason)
+            return [];
+        return [
+            {
+                scope: target.scope,
+                platform: target.platform,
+                platformName: target.platformName,
+                component: 'Skill',
+                status: 'failed',
+                failed,
+                reason: target.reason,
+            },
+        ];
+    });
+    const ruleFailures = result.rules.targets.flatMap((target) => {
+        if (target.failed === 0 || !target.reason)
+            return [];
+        return [
+            {
+                scope: target.scope,
+                platform: target.platform,
+                platformName: target.platformName,
+                component: 'Rule',
+                status: 'failed',
+                failed: target.failed,
+                reason: target.reason,
+            },
+        ];
+    });
+    const hookFailures = result.hooks.targets.flatMap((target) => {
+        if (target.failed === 0 || !target.reason)
+            return [];
+        return [
+            {
+                scope: target.scope,
+                platform: target.platform,
+                platformName: target.platformName,
+                component: 'Hook',
+                status: 'failed',
+                failed: target.failed,
+                reason: target.reason,
+            },
+        ];
+    });
+    return [...skillFailures, ...ruleFailures, ...hookFailures];
+}
+function summarizeTargets(targets) {
+    return targets.map((target) => ({
+        scope: target.scope,
+        platform: target.platform.id,
+        platformName: target.platform.name,
+        language: target.language,
+    }));
+}
+function summarizeUpdatedTargets(targets) {
+    return targets.map((target) => ({
+        scope: target.scope,
+        platform: target.platform,
+        platformName: target.platformName,
+        language: target.language,
+    }));
+}
+async function upsertUpdatedProjectTargets(projectPath, result) {
+    const projectTargets = result.skills.targets.filter((target) => target.scope === 'project');
+    if (projectTargets.length === 0)
+        return;
+    await upsertProjectInstallation(projectPath, projectTargets.map((target) => ({
+        platform: target.platform,
+        language: target.language,
+    })), 'update');
+}
+async function updateSingleProject(projectPath, options, log) {
+    const lang = options.language ?? 'en';
+    const packageScope = options.scope && !options.targetScopes
+        ? options.scope
+        : await detectCometPackageScope(projectPath);
     let npmStatus = 'skipped';
-    if (!options.skipNpm) {
+    const skipRepeatedGlobalNpm = !options.skipNpm && packageScope === 'global' && options.skipGlobalNpmUpdate === true;
+    if (skipRepeatedGlobalNpm) {
+        log(`  ${t(lang, 'updatingNpmPackage')}: skipped (global scope already attempted)`);
+    }
+    else if (!options.skipNpm) {
         log(`  ${t(lang, 'updatingNpmPackage')} (${packageScope} scope)...`);
         log(`    $ ${formatNpmUpdateCommand(packageScope)}`);
         const npmUpdated = await updateCometNpmPackage(packageScope, projectPath, log, options.json === true);
@@ -182,30 +340,31 @@ export async function updateCommand(targetPath, options = {}) {
         }
         else {
             npmStatus = 'failed';
-            log(`  ${t(lang, 'npmPackageFailed')}`);
+            log(`  ${t(lang, options.failOnNpmFailure ? 'npmPackageFailedBlocking' : 'npmPackageFailed')}`);
+            if (options.failOnNpmFailure) {
+                throw createNpmUpdateFailure(packageScope);
+            }
         }
     }
     const installMode = await selectInstallMode(options, lang);
     const targets = await detectInstalledCometTargets(projectPath, {
-        scopes: options.scope ? [options.scope] : undefined,
+        scopes: options.targetScopes ?? (options.scope ? [options.scope] : undefined),
+        respectDetectionPaths: options.scope === undefined,
     });
     if (targets.length === 0) {
-        if (options.json) {
-            console.log(JSON.stringify({
-                npm: {
-                    scope: options.skipNpm ? 'skipped' : packageScope,
-                    status: npmStatus,
-                    command: options.skipNpm ? null : formatNpmUpdateCommand(packageScope),
-                },
-                skills: { totalCopied: 0, targets: [] },
-                rules: { totalCopied: 0 },
-                hooks: { totalInstalled: 0 },
-                codegraph: 'skipped',
-            }, null, 2));
-            return;
-        }
-        log(`\n  ${t(lang, 'noInstallsFound')}\n`);
-        return;
+        return {
+            projectPath,
+            npm: {
+                scope: options.skipNpm ? 'skipped' : packageScope,
+                status: npmStatus,
+                command: options.skipNpm || skipRepeatedGlobalNpm ? null : formatNpmUpdateCommand(packageScope),
+            },
+            skills: { totalCopied: 0, totalFailed: 0, cleanupFailed: 0, targets: [] },
+            rules: { totalCopied: 0, totalFailed: 0, targets: [] },
+            hooks: { totalInstalled: 0, totalFailed: 0, targets: [] },
+            projectInstructions: { updated: 0 },
+            codegraph: 'skipped',
+        };
     }
     log(`\n  ${t(lang, 'updatingSkillsOnTargets')} ${targets.length} target(s):`);
     for (const target of targets) {
@@ -218,57 +377,176 @@ export async function updateCommand(targetPath, options = {}) {
     }
     log(`\n  ${t(lang, 'copyingSkillsFiles')} ${(await getManifestSkills()).length} skill files...\n`);
     let totalCopied = 0;
+    let totalFailed = 0;
+    let totalCleanupFailed = 0;
     let totalRulesCopied = 0;
+    let totalRulesFailed = 0;
     let totalHooksInstalled = 0;
+    let totalHooksFailed = 0;
+    let projectInstructionsUpdated = 0;
     const targetResults = [];
+    const ruleTargetResults = [];
+    const hookTargetResults = [];
     for (const target of targets) {
         const baseDir = getBaseDir(target.scope, projectPath);
         const languageId = resolveTargetLanguage(options.language, target.language);
         const languageSkillsDir = languageToSkillsDir(languageId);
-        const { copied, skipped } = await copyCometSkillsForPlatform(baseDir, target.platform, true, languageSkillsDir, target.scope, installMode);
+        const { copied, skipped, failed } = await copyCometSkillsForPlatform(baseDir, target.platform, true, languageSkillsDir, target.scope, installMode);
+        const cleanupResult = failed === 0
+            ? await removeLegacyCometSkillsForPlatform(baseDir, target.platform, target.scope)
+            : { removed: 0, failed: 0 };
+        totalCleanupFailed += cleanupResult.failed;
         totalCopied += copied;
+        totalFailed += failed;
         targetResults.push({
             scope: target.scope,
             platform: target.platform.id,
             platformName: target.platform.name,
-            language: options.language ?? target.language,
+            language: languageId,
             source: languageSkillsDir,
             copied,
             skipped,
+            failed,
+            reason: failed > 0
+                ? `${failed} Skill file(s) failed to install`
+                : cleanupResult.failed > 0
+                    ? `legacy Skill cleanup failed (${cleanupResult.failed})`
+                    : undefined,
+            cleanupFailed: cleanupResult.failed,
             command: formatSkillUpdateCommand(target.scope, target.platform, languageSkillsDir, installMode),
         });
         log(`  ${target.platform.name} (${target.scope}, ${languageSkillsDir}): ${copied} ${t(lang, 'skillsCopiedSkipped')} ${skipped} skipped`);
+        if (cleanupResult.failed > 0) {
+            log(`  ${target.platform.name} (${target.scope}): legacy Skill cleanup failed; update incomplete`);
+        }
+        if (failed > 0) {
+            const dependencyReason = 'skipped because Skill installation failed';
+            ruleTargetResults.push({
+                scope: target.scope,
+                platform: target.platform.id,
+                platformName: target.platform.name,
+                copied: 0,
+                skipped: 0,
+                failed: 0,
+                status: 'skipped',
+                reason: dependencyReason,
+            });
+            hookTargetResults.push({
+                scope: target.scope,
+                platform: target.platform.id,
+                platformName: target.platform.name,
+                failed: 0,
+                status: 'skipped',
+                reason: dependencyReason,
+            });
+            continue;
+        }
         try {
-            const { copied: ruleCopied } = await copyCometRulesForPlatform(baseDir, target.platform, true, languageId, target.scope);
-            totalRulesCopied += ruleCopied;
-            if (ruleCopied > 0) {
-                log(`  Comet rules -> ${target.platform.name}: ${ruleCopied} ${t(lang, 'rulesUpdated')}`);
+            const ruleResult = await copyCometRulesForPlatform(baseDir, target.platform, true, languageId, target.scope);
+            totalRulesCopied += ruleResult.copied;
+            totalRulesFailed += ruleResult.failed;
+            const ruleStatus = ruleResult.failed > 0 ? 'failed' : ruleResult.copied > 0 ? 'copied' : 'skipped';
+            const ruleReason = ruleResult.failed > 0
+                ? `${ruleResult.failed} Rule file(s) failed to install`
+                : !target.platform.rulesDir || !target.platform.rulesFormat
+                    ? 'platform does not support rules'
+                    : undefined;
+            ruleTargetResults.push({
+                scope: target.scope,
+                platform: target.platform.id,
+                platformName: target.platform.name,
+                ...ruleResult,
+                status: ruleStatus,
+                reason: ruleReason,
+            });
+            if (ruleResult.copied > 0) {
+                log(`  Comet rules -> ${target.platform.name}: ${ruleResult.copied} ${t(lang, 'rulesUpdated')}`);
+            }
+            if (ruleResult.failed > 0) {
+                log(`  Comet rules -> ${target.platform.name}: ${t(lang, 'rulesFailed')} (${ruleReason})`);
             }
         }
         catch (err) {
-            log(`  Comet rules -> ${target.platform.name}: ${t(lang, 'rulesFailed')} (${err.message})`);
+            totalRulesFailed++;
+            const reason = err.message;
+            ruleTargetResults.push({
+                scope: target.scope,
+                platform: target.platform.id,
+                platformName: target.platform.name,
+                copied: 0,
+                skipped: 0,
+                failed: 1,
+                status: 'failed',
+                reason,
+            });
+            log(`  Comet rules -> ${target.platform.name}: ${t(lang, 'rulesFailed')} (${reason})`);
         }
-        if (target.platform.supportsHooks) {
-            try {
-                const { installed, reason } = await installCometHooksForPlatform(baseDir, target.platform, target.scope);
-                if (installed) {
-                    totalHooksInstalled++;
-                    log(`  Comet hooks -> ${target.platform.name}: ${t(lang, 'hooksUpdated')}`);
-                }
-                else if (reason) {
-                    log(`  Comet hooks -> ${target.platform.name}: ${t(lang, 'hooksSkipped')} (${reason})`);
-                }
+        try {
+            const { status, reason } = await installCometHooksForPlatform(baseDir, target.platform, target.scope);
+            const hookFailed = status === 'failed' ? 1 : 0;
+            totalHooksFailed += hookFailed;
+            hookTargetResults.push({
+                scope: target.scope,
+                platform: target.platform.id,
+                platformName: target.platform.name,
+                failed: hookFailed,
+                status,
+                reason,
+            });
+            if (status === 'installed') {
+                totalHooksInstalled++;
+                log(`  Comet hooks -> ${target.platform.name}: ${t(lang, 'hooksUpdated')}`);
             }
-            catch (err) {
-                log(`  Comet hooks -> ${target.platform.name}: ${t(lang, 'hooksFailed')} (${err.message})`);
+            else if (status === 'failed') {
+                log(`  Comet hooks -> ${target.platform.name}: ${t(lang, 'hooksFailed')} (${reason})`);
+            }
+            else if (reason && target.platform.supportsHooks) {
+                log(`  Comet hooks -> ${target.platform.name}: ${t(lang, 'hooksSkipped')} (${reason})`);
             }
         }
+        catch (err) {
+            totalHooksFailed++;
+            const reason = err.message;
+            hookTargetResults.push({
+                scope: target.scope,
+                platform: target.platform.id,
+                platformName: target.platform.name,
+                failed: 1,
+                status: 'failed',
+                reason,
+            });
+            log(`  Comet hooks -> ${target.platform.name}: ${t(lang, 'hooksFailed')} (${reason})`);
+        }
     }
-    const hasProjectTargets = targets.some((target) => target.scope === 'project');
-    if (hasProjectTargets) {
-        await mergeProjectConfig(projectPath);
+    for (const scope of ['project', 'global']) {
+        const scopeTargets = targets.filter((candidate) => candidate.scope === scope);
+        if (scopeTargets.length === 0)
+            continue;
+        // An explicit --language always wins. Otherwise only force the persisted language when
+        // every platform installed at this scope agrees — if two platforms disagree (e.g. one
+        // installed with English skills, another with Chinese) and the user didn't say which one
+        // they mean, guessing from array order would silently override whatever language they
+        // (or a prior install) already configured. Pass null in that case so mergeProjectConfig
+        // preserves the existing config's language instead of guessing.
+        const agreedLanguage = scopeTargets.every((t) => t.language === scopeTargets[0].language)
+            ? scopeTargets[0].language
+            : undefined;
+        const languageId = options.language
+            ? resolveTargetLanguage(options.language, scopeTargets[0].language)
+            : agreedLanguage;
+        const configRoot = getBaseDir(scope, projectPath);
+        await mergeProjectConfig(configRoot, languageId ? languageToArtifactLanguage(languageId) : null);
         log(`  ${t(lang, 'configMerged')}`);
     }
+    const projectTarget = targets.find((target) => target.scope === 'project');
+    if (projectTarget) {
+        const projectLanguageId = resolveTargetLanguage(options.language, projectTarget.language);
+        const projectInstructionResult = await installCometProjectInstructions(projectPath, projectLanguageId);
+        projectInstructionsUpdated = projectInstructionResult.changed;
+        if (projectInstructionsUpdated > 0) {
+            log(`  Comet project instructions -> ${projectInstructionsUpdated} file(s) updated`);
+        }
+    }
     let codegraphStatus = 'skipped';
     const primaryScope = targets[0]?.scope ?? 'project';
     const codegraphAlreadyIndexed = hasCodegraphProjectIndex(projectPath);
@@ -289,33 +567,227 @@ export async function updateCommand(targetPath, options = {}) {
             log(`\n  CodeGraph: ${t(lang, 'cgSkippedByUser')}`);
         }
     }
+    return {
+        projectPath,
+        npm: {
+            scope: options.skipNpm ? 'skipped' : packageScope,
+            status: npmStatus,
+            command: options.skipNpm || skipRepeatedGlobalNpm ? null : formatNpmUpdateCommand(packageScope),
+        },
+        skills: {
+            totalCopied,
+            totalFailed,
+            cleanupFailed: totalCleanupFailed,
+            installMode,
+            targets: targetResults,
+        },
+        rules: {
+            totalCopied: totalRulesCopied,
+            totalFailed: totalRulesFailed,
+            targets: ruleTargetResults,
+        },
+        hooks: {
+            totalInstalled: totalHooksInstalled,
+            totalFailed: totalHooksFailed,
+            targets: hookTargetResults,
+        },
+        projectInstructions: { updated: projectInstructionsUpdated },
+        codegraph: codegraphStatus,
+    };
+}
+function logSingleProjectSummary(result, options, log) {
+    const lang = options.language ?? 'en';
+    const languages = [...new Set(result.skills.targets.map((target) => target.language))].join(', ');
+    const scopes = [...new Set(result.skills.targets.map((target) => target.scope))].join(', ');
+    log(`\n  ${t(lang, 'summary')}`);
+    log(`    ${t(lang, 'summaryNpm')} ${result.npm.status}${options.skipNpm ? '' : ` (${result.npm.scope})`}`);
+    log(`    ${t(lang, 'summarySkills')} ${result.skills.targets.length} target(s), ${result.skills.totalCopied} files updated`);
+    if (result.skills.cleanupFailed > 0) {
+        log(`    Skill cleanup failures: ${result.skills.cleanupFailed} (update incomplete)`);
+    }
+    if (result.skills.totalFailed > 0) {
+        log(`    Skill failures: ${result.skills.totalFailed} (update incomplete)`);
+    }
+    if (result.rules.totalFailed > 0) {
+        log(`    Rule failures: ${result.rules.totalFailed} (update incomplete)`);
+    }
+    if (result.hooks.totalFailed > 0) {
+        log(`    Hook failures: ${result.hooks.totalFailed} (update incomplete)`);
+    }
+    for (const failure of collectComponentFailures(result)) {
+        log(`    ${failure.platformName} (${failure.scope}) ${failure.component}: ${failure.status} (${failure.failed}) - ${failure.reason}`);
+    }
+    log(`    ${t(lang, 'summaryCodegraph')} ${result.codegraph}`);
+    log(`    ${t(lang, 'summaryScope')} ${scopes}`);
+    log(`    ${t(lang, 'summaryLanguage')} ${languages}`);
+    if (hasComponentFailures(result)) {
+        log(`\n  Update incomplete. ${componentFailureReason(result)}.\n`);
+    }
+    else {
+        log(`\n  ${t(lang, 'updateComplete')}\n`);
+    }
+}
+async function updateAllIndexedProjects(registryProjects, options, log) {
+    const lang = options.language ?? 'en';
+    const results = [];
+    const runnableProjects = [];
+    let staleRemoved = 0;
+    for (const project of registryProjects) {
+        const projectPath = project.path;
+        try {
+            const targets = await detectInstalledCometTargets(projectPath, { scopes: ['project'] });
+            if (targets.length === 0) {
+                if (await removeProjectInstallation(projectPath))
+                    staleRemoved++;
+                results.push({
+                    projectPath,
+                    status: 'skipped',
+                    reason: 'no project-scope Comet install detected',
+                    targets: [],
+                });
+                continue;
+            }
+            runnableProjects.push({ projectPath, targets });
+        }
+        catch (error) {
+            results.push({
+                projectPath,
+                status: 'skipped',
+                reason: `unable to inspect project: ${error.message}`,
+                targets: [],
+            });
+        }
+    }
+    if (!options.json) {
+        log(`  Comet will update ${runnableProjects.length} indexed project(s):`);
+        for (const project of runnableProjects) {
+            log(`    - ${project.projectPath}`);
+            log(`      ${project.targets.map((target) => target.platform.name).join(', ')}`);
+        }
+        const confirmed = await select({
+            message: t(lang, 'updateAllProjectsPrompt'),
+            choices: [
+                { name: t(lang, 'updateAllProjectsYes'), value: true },
+                { name: t(lang, 'updateAllProjectsNo'), value: false },
+            ],
+        });
+        if (!confirmed) {
+            log(`\n  ${t(lang, 'cancelled')}\n`);
+            return;
+        }
+    }
+    const runOptions = {
+        ...options,
+        scope: undefined,
+        targetScopes: ['project'],
+        currentProject: true,
+        allProjects: false,
+        failOnNpmFailure: true,
+    };
+    if (!options.json && !runOptions.installMode) {
+        runOptions.installMode = await selectInstallMode(options, lang);
+    }
+    let globalNpmAttempted = false;
+    for (const project of runnableProjects) {
+        const { projectPath, targets } = project;
+        try {
+            const result = await updateSingleProject(projectPath, { ...runOptions, skipGlobalNpmUpdate: globalNpmAttempted }, log);
+            if (result.npm.scope === 'global' && result.npm.status !== 'skipped') {
+                globalNpmAttempted = true;
+            }
+            if (result.skills.targets.length === 0) {
+                if (await removeProjectInstallation(projectPath))
+                    staleRemoved++;
+                results.push({
+                    projectPath,
+                    status: 'skipped',
+                    reason: 'no project-scope Comet install detected',
+                    targets: [],
+                });
+                continue;
+            }
+            if (hasComponentFailures(result)) {
+                results.push({
+                    projectPath,
+                    status: 'failed',
+                    reason: componentFailureReason(result),
+                    targets: summarizeUpdatedTargets(result.skills.targets),
+                    failures: collectComponentFailures(result),
+                });
+                continue;
+            }
+            await upsertUpdatedProjectTargets(projectPath, result);
+            results.push({
+                projectPath,
+                status: 'updated',
+                targets: summarizeUpdatedTargets(result.skills.targets),
+                summary: {
+                    skillsCopied: result.skills.totalCopied,
+                    rulesCopied: result.rules.totalCopied,
+                    hooksInstalled: result.hooks.totalInstalled,
+                    projectInstructionsUpdated: result.projectInstructions.updated,
+                },
+            });
+        }
+        catch (error) {
+            results.push({
+                projectPath,
+                status: 'failed',
+                reason: error.message,
+                targets: summarizeTargets(targets),
+            });
+            if (isGlobalNpmUpdateFailure(error))
+                break;
+        }
+    }
     if (options.json) {
         console.log(JSON.stringify({
-            npm: {
-                scope: options.skipNpm ? 'skipped' : packageScope,
-                status: npmStatus,
-                command: options.skipNpm ? null : formatNpmUpdateCommand(packageScope),
+            mode: 'all-projects',
+            registry: {
+                projectsFound: registryProjects.length,
+                staleRemoved,
             },
-            skills: {
-                totalCopied,
-                installMode,
-                targets: targetResults,
-            },
-            rules: { totalCopied: totalRulesCopied },
-            hooks: { totalInstalled: totalHooksInstalled },
-            codegraph: codegraphStatus,
+            projects: results,
         }, null, 2));
         return;
     }
-    const languages = [...new Set(targetResults.map((target) => target.language))].join(', ');
-    const scopes = [...new Set(targetResults.map((target) => target.scope))].join(', ');
-    log(`\n  ${t(lang, 'summary')}`);
-    log(`    ${t(lang, 'summaryNpm')} ${npmStatus}${options.skipNpm ? '' : ` (${packageScope})`}`);
-    log(`    ${t(lang, 'summarySkills')} ${targets.length} target(s), ${totalCopied} files updated`);
-    log(`    ${t(lang, 'summaryCodegraph')} ${codegraphStatus}`);
-    log(`    ${t(lang, 'summaryScope')} ${scopes}`);
-    log(`    ${t(lang, 'summaryLanguage')} ${languages}`);
-    log(`\n  ${t(lang, 'updateComplete')}\n`);
+    log(`\n  Updated ${results.filter((result) => result.status === 'updated').length} indexed project(s).`);
+}
+export async function updateCommand(targetPath, options = {}) {
+    const projectPath = path.resolve(targetPath);
+    const log = options.json ? () => undefined : console.log;
+    const lang = options.language ?? 'en';
+    assertProjectScopeOptions(options);
+    const registryProjects = await listProjectRegistryEntries({
+        strict: options.allProjects === true,
+    });
+    log(`\n  ${t(lang, 'updateTitle')}`);
+    if (!options.json) {
+        await printVersionInfo(log);
+    }
+    log('');
+    const scopeMode = await resolveProjectScopeMode('update', options, registryProjects.length);
+    if (scopeMode === 'all-projects') {
+        await updateAllIndexedProjects(registryProjects, options, log);
+        return;
+    }
+    const result = await updateSingleProject(projectPath, options, log);
+    if (result.skills.targets.length === 0) {
+        if (options.json) {
+            console.log(JSON.stringify(currentProjectJson(result), null, 2));
+            return;
+        }
+        log(`\n  ${t(lang, 'noInstallsFound')}\n`);
+        return;
+    }
+    if (!hasComponentFailures(result)) {
+        await upsertUpdatedProjectTargets(projectPath, result);
+    }
+    if (options.json) {
+        console.log(JSON.stringify(currentProjectJson(result), null, 2));
+        return;
+    }
+    logSingleProjectSummary(result, options, log);
 }
 export { buildNpmUpdateArgs, detectCometPackageScope, detectInstalledCometLanguage, detectInstalledCometTargets, formatNpmUpdateCommand, formatSkillUpdateCommand, };
 //# sourceMappingURL=update.js.map