@gramatr/mcp 0.7.5 → 0.7.10

package/dist/bin/setup.js

@@ -9,7 +9,7 @@
  *   gramatr-mcp setup claude       Configure Claude Code
  *   gramatr-mcp setup claude --dry Run without writing
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync, statSync, lstatSync, readlinkSync, unlinkSync, } from 'node:fs';
 import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getGramatrDirFromEnv, getGramatrUrlFromEnv } from '../config-runtime.js';
@@ -21,6 +21,48 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // gramatr-allow: C1 — CLI entry point, reads HOME for config path
 const HOME = process.env.HOME || process.env.USERPROFILE || '';
+export const AUTO_TARGET_ORDER = [
+    'claude',
+    'codex',
+    'gemini',
+    'claude-desktop',
+    'chatgpt-desktop',
+    'cursor',
+    'windsurf',
+    'vscode',
+];
+const LEGACY_HOOK_BASENAMES = [
+    'LoadContext.hook.ts',
+    'SecurityValidator.hook.ts',
+    'RatingCapture.hook.ts',
+    'VoiceGate.hook.ts',
+    'AutoWorkCreation.hook.ts',
+    'WorkCompletionLearning.hook.ts',
+    'RelationshipMemory.hook.ts',
+    'SessionSummary.hook.ts',
+    'UpdateCounts.hook.ts',
+    'IntegrityCheck.hook.ts',
+];
+const LEGACY_MCP_KEY_PATTERNS = [/^aios/i, /^pai$/i, /^pai[-_]/i, /^fabric/i];
+const LEGACY_CLAUDE_ARTIFACT_PATTERNS = [
+    /^pai[-_]/i,
+    /^pai$/i,
+    /^fabric[-_]/i,
+    /^fabric$/i,
+    /^aios[-_]/i,
+    /^aios$/i,
+    /^extract[-_]?wisdom/i,
+    /^pattern[-_]/i,
+    /^official[-_]?pattern/i,
+    /^becreative$/i,
+    /^beexpert$/i,
+];
+const LEGACY_MANAGED_BLOCK_MARKERS = [
+    { start: '<!-- AIOS-START -->', end: '<!-- AIOS-END -->' },
+    { start: '<!-- PAI-START -->', end: '<!-- PAI-END -->' },
+    { start: '<!-- FABRIC-START -->', end: '<!-- FABRIC-END -->' },
+    { start: '<!-- GMTR-START -->', end: '<!-- GMTR-END -->' },
+];
 /**
  * Resolve the path to the gramatr-mcp binary.
  * Prefers the compiled dist version, falls back to npx.
@@ -117,6 +159,252 @@ export function ensureLocalSettings() {
     mkdirSync(settingsDir, { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(next, null, 2) + '\n', 'utf8');
 }
+function matchesLegacyClaudeArtifact(name) {
+    const stem = name.replace(/\.md$/i, '');
+    return LEGACY_CLAUDE_ARTIFACT_PATTERNS.some((pattern) => pattern.test(stem));
+}
+function sanitizeLegacyMcpServers(raw) {
+    if (!raw.mcpServers || typeof raw.mcpServers !== 'object')
+        return raw;
+    const servers = raw.mcpServers;
+    const next = {};
+    for (const [key, value] of Object.entries(servers)) {
+        if (LEGACY_MCP_KEY_PATTERNS.some((pattern) => pattern.test(key)))
+            continue;
+        next[key] = value;
+    }
+    return { ...raw, mcpServers: next };
+}
+function stripManagedBlock(content, startMarker, endMarker) {
+    const pattern = new RegExp(`${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}\\n?`, 'gm');
+    return content.replace(pattern, '').trimEnd() + '\n';
+}
+function isLegacyHookCommand(command) {
+    if (command.includes('/.claude/hooks/'))
+        return true;
+    if (command.includes('/aios-v2-client/'))
+        return true;
+    if (command.includes('/fabric/'))
+        return true;
+    if (command.includes('/pai/'))
+        return true;
+    return LEGACY_HOOK_BASENAMES.some((basename) => command.includes(`/${basename}`));
+}
+function sanitizeHookEventArray(value) {
+    if (!Array.isArray(value))
+        return value;
+    return value
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return entry;
+        const commands = entry.hooks;
+        if (!Array.isArray(commands))
+            return entry;
+        const filtered = commands.filter((cmd) => {
+            const command = typeof cmd?.command === 'string' ? cmd.command : '';
+            return !command || !isLegacyHookCommand(command);
+        });
+        if (filtered.length === 0)
+            return null;
+        return { ...entry, hooks: filtered };
+    })
+        .filter(Boolean);
+}
+function sanitizeHookFile(hookFile) {
+    const hooksRoot = hookFile.hooks;
+    if (!hooksRoot || typeof hooksRoot !== 'object')
+        return hookFile;
+    const nextHooks = { ...hooksRoot };
+    for (const [eventName, value] of Object.entries(nextHooks)) {
+        nextHooks[eventName] = sanitizeHookEventArray(value);
+    }
+    return { ...hookFile, hooks: nextHooks };
+}
+function removeDirectoryIfExists(path, dryRun) {
+    if (!existsSync(path))
+        return;
+    if (dryRun) {
+        process.stderr.write(`[gramatr-mcp] clean-install dry-run: would remove ${path}\n`);
+        return;
+    }
+    rmSync(path, { recursive: true, force: true });
+    process.stderr.write(`[gramatr-mcp] clean-install: removed ${path}\n`);
+}
+function removeFileIfExists(path, dryRun) {
+    if (!existsSync(path))
+        return;
+    if (dryRun) {
+        process.stderr.write(`[gramatr-mcp] clean-install dry-run: would remove ${path}\n`);
+        return;
+    }
+    rmSync(path, { force: true });
+    process.stderr.write(`[gramatr-mcp] clean-install: removed ${path}\n`);
+}
+function cleanLegacyClaudeArtifacts(dryRun) {
+    process.stderr.write('[gramatr-mcp] clean-install: removing legacy Claude + PAI/Fabric/AIOS artifacts\n');
+    const legacyDirs = [
+        join(HOME, 'aios-v2-client'),
+        join(HOME, '.claude', 'hooks'),
+    ];
+    for (const dir of legacyDirs)
+        removeDirectoryIfExists(dir, dryRun);
+    const commandsDir = join(HOME, '.claude', 'commands');
+    if (existsSync(commandsDir)) {
+        try {
+            for (const entry of readdirSync(commandsDir)) {
+                if (!entry.endsWith('.md'))
+                    continue;
+                if (!matchesLegacyClaudeArtifact(entry))
+                    continue;
+                removeFileIfExists(join(commandsDir, entry), dryRun);
+            }
+        }
+        catch {
+            // non-critical
+        }
+    }
+    const skillsDir = join(HOME, '.claude', 'skills');
+    if (existsSync(skillsDir)) {
+        try {
+            for (const entry of readdirSync(skillsDir)) {
+                const path = join(skillsDir, entry);
+                if (!statSync(path).isDirectory())
+                    continue;
+                if (!matchesLegacyClaudeArtifact(entry))
+                    continue;
+                removeDirectoryIfExists(path, dryRun);
+            }
+        }
+        catch {
+            // non-critical
+        }
+    }
+    const clientHooksDir = join(HOME, '.gramatr', 'hooks');
+    if (existsSync(clientHooksDir)) {
+        for (const basename of LEGACY_HOOK_BASENAMES) {
+            removeFileIfExists(join(clientHooksDir, basename), dryRun);
+        }
+        try {
+            for (const entry of readdirSync(clientHooksDir)) {
+                if (!entry.endsWith('.sh'))
+                    continue;
+                removeFileIfExists(join(clientHooksDir, entry), dryRun);
+            }
+        }
+        catch {
+            // non-critical
+        }
+    }
+}
+function sanitizeLegacyMcpServersInFile(path, dryRun) {
+    const current = readJsonFile(path, {});
+    const next = sanitizeLegacyMcpServers(current);
+    if (JSON.stringify(next) === JSON.stringify(current))
+        return;
+    if (dryRun) {
+        process.stderr.write(`[gramatr-mcp] clean-install dry-run: would sanitize legacy mcpServers in ${path}\n`);
+        return;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(next, null, 2) + '\n', 'utf8');
+    process.stderr.write(`[gramatr-mcp] clean-install: sanitized legacy mcpServers in ${path}\n`);
+}
+function sanitizeHookFileAtPath(path, dryRun, label) {
+    const current = readJsonFile(path, {});
+    const next = sanitizeHookFile(current);
+    if (JSON.stringify(next) === JSON.stringify(current))
+        return;
+    if (dryRun) {
+        process.stderr.write(`[gramatr-mcp] clean-install dry-run: would sanitize legacy hooks in ${path}\n`);
+        return;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(next, null, 2) + '\n', 'utf8');
+    process.stderr.write(`[gramatr-mcp] clean-install: sanitized legacy hooks (${label}) in ${path}\n`);
+}
+function stripLegacyManagedBlocks(path, dryRun) {
+    if (!existsSync(path))
+        return;
+    const current = readFileSync(path, 'utf8');
+    let next = current;
+    for (const marker of LEGACY_MANAGED_BLOCK_MARKERS) {
+        next = stripManagedBlock(next, marker.start, marker.end);
+    }
+    if (next === current)
+        return;
+    if (dryRun) {
+        process.stderr.write(`[gramatr-mcp] clean-install dry-run: would strip legacy managed blocks in ${path}\n`);
+        return;
+    }
+    writeFileSync(path, next, 'utf8');
+    process.stderr.write(`[gramatr-mcp] clean-install: stripped legacy managed blocks in ${path}\n`);
+}
+function cleanAllInstallTargets(dryRun) {
+    sanitizeLegacyMcpServersInFile(getClaudeConfigPath(), dryRun);
+    sanitizeLegacyMcpServersInFile(join(HOME, '.claude', 'mcp.json'), dryRun);
+    sanitizeLegacyMcpServersInFile(getClaudeDesktopConfigPath(HOME), dryRun);
+    sanitizeLegacyMcpServersInFile(getChatgptDesktopConfigPath(HOME), dryRun);
+    sanitizeLegacyMcpServersInFile(getCursorConfigPath(HOME), dryRun);
+    sanitizeLegacyMcpServersInFile(getWindsurfConfigPath(HOME), dryRun);
+    sanitizeLegacyMcpServersInFile(getVscodeConfigPath(HOME), dryRun);
+    sanitizeLegacyMcpServersInFile(getGeminiManifestPath(HOME), dryRun);
+    sanitizeHookFileAtPath(getClaudeSettingsPath(), dryRun, 'claude');
+    sanitizeHookFileAtPath(getCodexHooksPath(), dryRun, 'codex');
+    sanitizeHookFileAtPath(getGeminiHooksPath(HOME), dryRun, 'gemini');
+    stripLegacyManagedBlocks(getClaudeMarkdownPath(), dryRun);
+    stripLegacyManagedBlocks(getCodexAgentsPath(), dryRun);
+}
+function cleanLegacyHomeNodeShims(dryRun) {
+    const candidates = new Set();
+    candidates.add(join(HOME, '.local', 'bin', 'gramatr-mcp'));
+    candidates.add(join(HOME, '.local', 'bin', 'gramatr'));
+    candidates.add(join(HOME, 'bin', 'gramatr-mcp'));
+    candidates.add(join(HOME, 'bin', 'gramatr'));
+    candidates.add(join(HOME, 'bin', 'gramatr-mac'));
+    for (const shimPath of candidates) {
+        if (!existsSync(shimPath))
+            continue;
+        try {
+            let stale = false;
+            if (lstatSync(shimPath).isSymbolicLink()) {
+                const target = readlinkSync(shimPath);
+                if (target.includes('aios-v2-client')
+                    || target.includes('/packages/client/bin/gramatr')
+                    || target.includes('/fabric/')
+                    || target.includes('/pai/')) {
+                    stale = true;
+                }
+            }
+            else {
+                const body = readFileSync(shimPath, 'utf8');
+                if (body.includes('aios-v2-client')
+                    || body.includes('/packages/client/bin/gramatr')
+                    || body.includes('/fabric/')
+                    || body.includes('/pai/')) {
+                    stale = true;
+                }
+            }
+            if (!stale)
+                continue;
+            if (dryRun) {
+                process.stderr.write(`[gramatr-mcp] clean-install dry-run: would remove stale shim ${shimPath}\n`);
+            }
+            else {
+                unlinkSync(shimPath);
+                process.stderr.write(`[gramatr-mcp] clean-install: removed stale shim ${shimPath}\n`);
+            }
+        }
+        catch {
+            // non-critical
+        }
+    }
+}
+export function runCleanInstall(dryRun) {
+    process.stderr.write('[gramatr-mcp] clean-install: running global legacy cleanup across known install targets\n');
+    cleanAllInstallTargets(dryRun);
+    cleanLegacyClaudeArtifacts(dryRun);
+    cleanLegacyHomeNodeShims(dryRun);
+}
 export function emitInstallPromptSuggestion(target) {
     const promptBlock = buildInstallPromptSuggestion(target);
     process.stderr.write('\n━━━ Prompt Suggestion (copy into custom instructions) ━━━\n\n');
@@ -124,7 +412,10 @@ export function emitInstallPromptSuggestion(target) {
     process.stderr.write('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
     process.stderr.write('[gramatr-mcp] Paste the prompt block above into your custom instructions / project knowledge.\n');
 }
-export function setupClaude(dryRun = false) {
+export function setupClaude(dryRun = false, cleanInstall = false) {
+    if (cleanInstall) {
+        runCleanInstall(dryRun);
+    }
     const configPath = getClaudeConfigPath();
     const settingsPath = getClaudeSettingsPath();
     const markdownPath = getClaudeMarkdownPath();
@@ -277,6 +568,75 @@ export function setupVscode(dryRun = false) {
     if (!dryRun)
         emitInstallPromptSuggestion('vscode');
 }
+export function getAutoDetectedTargets() {
+    const checks = {
+        claude: existsSync(join(HOME, '.claude')) || existsSync(getClaudeConfigPath()),
+        codex: existsSync(join(HOME, '.codex')),
+        gemini: existsSync(join(HOME, '.gemini')),
+        'claude-desktop': existsSync(dirname(getClaudeDesktopConfigPath(HOME))),
+        'chatgpt-desktop': existsSync(dirname(getChatgptDesktopConfigPath(HOME))),
+        cursor: existsSync(join(HOME, '.cursor')),
+        windsurf: existsSync(join(HOME, '.windsurf')),
+        vscode: existsSync(join(HOME, '.vscode')),
+    };
+    return AUTO_TARGET_ORDER.filter((target) => checks[target]);
+}
+export function setupAutoInstall(options = {}) {
+    const dryRun = options.dryRun === true;
+    const cleanInstall = options.cleanInstall === true;
+    const listOnly = options.listOnly === true;
+    const detected = getAutoDetectedTargets();
+    const selected = Array.isArray(options.selectedTargets) && options.selectedTargets.length > 0
+        ? detected.filter((target) => options.selectedTargets.includes(target))
+        : detected;
+    process.stderr.write('[gramatr-mcp] auto-detect scan complete\n');
+    if (detected.length === 0) {
+        process.stderr.write('[gramatr-mcp] No supported local clients detected.\n');
+        process.stderr.write('[gramatr-mcp] Install manually with: setup <target>\n');
+        return 0;
+    }
+    process.stderr.write(`[gramatr-mcp] Detected targets: ${detected.join(', ')}\n`);
+    process.stderr.write(`[gramatr-mcp] Selected targets: ${selected.join(', ')}\n`);
+    if (listOnly) {
+        process.stderr.write('[gramatr-mcp] list-only mode: no setup changes made.\n');
+        return selected.length;
+    }
+    if (cleanInstall) {
+        runCleanInstall(dryRun);
+    }
+    for (const target of selected) {
+        switch (target) {
+            case 'claude':
+                setupClaude(dryRun, false);
+                break;
+            case 'codex':
+                setupCodex(dryRun);
+                break;
+            case 'gemini':
+                setupGemini(dryRun);
+                break;
+            case 'claude-desktop':
+                setupClaudeDesktop(dryRun);
+                break;
+            case 'chatgpt-desktop':
+                setupChatgptDesktop(dryRun);
+                break;
+            case 'cursor':
+                setupCursor(dryRun);
+                break;
+            case 'windsurf':
+                setupWindsurf(dryRun);
+                break;
+            case 'vscode':
+                setupVscode(dryRun);
+                break;
+            default:
+                break;
+        }
+    }
+    process.stderr.write(`[gramatr-mcp] Auto setup completed for ${selected.length} target(s).\n`);
+    return selected.length;
+}
 export function setupGemini(dryRun = false) {
     const extensionDir = getGeminiExtensionDir(HOME);
     const manifestPath = getGeminiManifestPath(HOME);
@@ -330,4 +690,227 @@ export async function setupWeb(target = 'claude-web') {
     process.stderr.write('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
     process.stderr.write('[gramatr-mcp] Paste the prompt block above into your custom instructions / project knowledge.\n');
 }
+function addResult(items, severity, label, detail) {
+    items.push({ severity, label, detail });
+}
+function parseJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function hasHookCommand(config, eventName, needle) {
+    if (!config || typeof config !== 'object')
+        return false;
+    const hooksRoot = config.hooks;
+    if (!hooksRoot || typeof hooksRoot !== 'object')
+        return false;
+    const entries = hooksRoot[eventName];
+    if (!Array.isArray(entries))
+        return false;
+    for (const entry of entries) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const commands = entry.hooks;
+        if (!Array.isArray(commands))
+            continue;
+        for (const command of commands) {
+            const value = command?.command;
+            if (typeof value === 'string' && value.includes(needle)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function readManagedBlock(path, startMarker, endMarker) {
+    if (!existsSync(path))
+        return null;
+    const body = readFileSync(path, 'utf8');
+    const pattern = new RegExp(`${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}`, 'm');
+    const match = body.match(pattern);
+    return match ? match[0] : null;
+}
+function verifyClaude(items) {
+    const configPath = getClaudeConfigPath();
+    const settingsPath = getClaudeSettingsPath();
+    const markdownPath = getClaudeMarkdownPath();
+    const config = parseJson(configPath);
+    const gramatrServer = config?.mcpServers && typeof config.mcpServers === 'object'
+        ? config.mcpServers.gramatr
+        : null;
+    if (gramatrServer) {
+        addResult(items, 'ok', 'claude.mcp_server', `${configPath} contains mcpServers.gramatr`);
+    }
+    else {
+        addResult(items, 'error', 'claude.mcp_server', `${configPath} missing mcpServers.gramatr`);
+    }
+    const settings = parseJson(settingsPath);
+    const hasPromptHook = hasHookCommand(settings, 'UserPromptSubmit', 'hook user-prompt-submit');
+    const hasSessionStartHook = hasHookCommand(settings, 'SessionStart', 'hook session-start');
+    if (hasPromptHook && hasSessionStartHook) {
+        addResult(items, 'ok', 'claude.hooks', `${settingsPath} includes session-start + user-prompt-submit`);
+    }
+    else {
+        addResult(items, 'error', 'claude.hooks', `${settingsPath} missing required hooks (session-start=${hasSessionStartHook}, user-prompt-submit=${hasPromptHook})`);
+    }
+    const managedBlock = readManagedBlock(markdownPath, CLAUDE_BLOCK_START, CLAUDE_BLOCK_END);
+    if (managedBlock) {
+        addResult(items, 'ok', 'claude.guidance', `${markdownPath} contains managed gramatr guidance block`);
+    }
+    else {
+        addResult(items, 'warn', 'claude.guidance', `${markdownPath} missing managed guidance block`);
+    }
+}
+function verifyCodex(items) {
+    const hooksPath = getCodexHooksPath();
+    const configPath = getCodexConfigPath();
+    const agentsPath = getCodexAgentsPath();
+    const hooks = parseJson(hooksPath);
+    const hasPromptHook = hasHookCommand(hooks, 'UserPromptSubmit', 'hook user-prompt-submit');
+    const hasSessionStartHook = hasHookCommand(hooks, 'SessionStart', 'hook session-start');
+    const hasStopHook = hasHookCommand(hooks, 'Stop', 'hook stop');
+    if (hasPromptHook && hasSessionStartHook && hasStopHook) {
+        addResult(items, 'ok', 'codex.hooks', `${hooksPath} includes session-start + user-prompt-submit + stop`);
+    }
+    else {
+        addResult(items, 'error', 'codex.hooks', `${hooksPath} missing required hooks (session-start=${hasSessionStartHook}, user-prompt-submit=${hasPromptHook}, stop=${hasStopHook})`);
+    }
+    const configToml = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
+    const hooksEnabled = /^\s*codex_hooks\s*=\s*true\s*$/m.test(configToml);
+    if (hooksEnabled) {
+        addResult(items, 'ok', 'codex.feature_flag', `${configPath} enables codex_hooks`);
+    }
+    else {
+        addResult(items, 'error', 'codex.feature_flag', `${configPath} missing codex_hooks = true`);
+    }
+    const managedBlock = readManagedBlock(agentsPath, CODEX_BLOCK_START, CODEX_BLOCK_END);
+    if (managedBlock) {
+        addResult(items, 'ok', 'codex.guidance', `${agentsPath} contains managed gramatr guidance block`);
+    }
+    else {
+        addResult(items, 'warn', 'codex.guidance', `${agentsPath} missing managed guidance block`);
+    }
+}
+function verifyJsonMcpTarget(items, label, configPath) {
+    const json = parseJson(configPath);
+    const gramatrServer = json?.mcpServers && typeof json.mcpServers === 'object'
+        ? json.mcpServers.gramatr
+        : null;
+    if (gramatrServer) {
+        addResult(items, 'ok', `${label}.mcp_server`, `${configPath} contains mcpServers.gramatr`);
+    }
+    else {
+        addResult(items, 'warn', `${label}.mcp_server`, `${configPath} missing mcpServers.gramatr`);
+    }
+}
+function verifyGemini(items) {
+    const manifestPath = getGeminiManifestPath(HOME);
+    const hooksPath = getGeminiHooksPath(HOME);
+    const manifest = parseJson(manifestPath);
+    const geminiServer = manifest?.mcpServers && typeof manifest.mcpServers === 'object'
+        ? manifest.mcpServers.gramatr
+        : null;
+    if (geminiServer) {
+        addResult(items, 'ok', 'gemini.manifest', `${manifestPath} contains mcpServers.gramatr`);
+    }
+    else {
+        addResult(items, 'warn', 'gemini.manifest', `${manifestPath} missing mcpServers.gramatr`);
+    }
+    const hooks = parseJson(hooksPath);
+    const hasBeforeAgent = hasHookCommand(hooks, 'BeforeAgent', 'hook user-prompt-submit');
+    const hasSessionStart = hasHookCommand(hooks, 'SessionStart', 'hook session-start');
+    if (hasBeforeAgent && hasSessionStart) {
+        addResult(items, 'ok', 'gemini.hooks', `${hooksPath} includes BeforeAgent + SessionStart hooks`);
+    }
+    else {
+        addResult(items, 'warn', 'gemini.hooks', `${hooksPath} missing expected hooks (before-agent=${hasBeforeAgent}, session-start=${hasSessionStart})`);
+    }
+}
+function verifyLocalSettings(items) {
+    const settingsPath = getGramatrSettingsPath();
+    const settings = parseJson(settingsPath);
+    if (!settings) {
+        addResult(items, 'error', 'runtime.settings', `${settingsPath} is missing or invalid JSON`);
+        return;
+    }
+    const hasPrincipal = Boolean(settings.principal?.name);
+    const hasIdentity = Boolean(settings.daidentity?.name);
+    if (hasPrincipal && hasIdentity) {
+        addResult(items, 'ok', 'runtime.settings', `${settingsPath} initialized with principal + daidentity`);
+    }
+    else {
+        addResult(items, 'warn', 'runtime.settings', `${settingsPath} missing expected fields (principal=${hasPrincipal}, daidentity=${hasIdentity})`);
+    }
+}
+function printPromptBlocks(target) {
+    if (target === 'all' || target === 'claude') {
+        const block = readManagedBlock(getClaudeMarkdownPath(), CLAUDE_BLOCK_START, CLAUDE_BLOCK_END);
+        process.stderr.write('\n━━━ Claude Managed Guidance Block ━━━\n\n');
+        process.stdout.write((block || '[missing managed block]\n') + '\n');
+    }
+    if (target === 'all' || target === 'codex') {
+        const block = readManagedBlock(getCodexAgentsPath(), CODEX_BLOCK_START, CODEX_BLOCK_END);
+        process.stderr.write('\n━━━ Codex Managed Guidance Block ━━━\n\n');
+        process.stdout.write((block || '[missing managed block]\n') + '\n');
+    }
+}
+export function verifySetupInstall(target = 'all', options = {}) {
+    const items = [];
+    verifyLocalSettings(items);
+    if (target === 'all' || target === 'claude')
+        verifyClaude(items);
+    if (target === 'all' || target === 'codex')
+        verifyCodex(items);
+    if (target === 'all' || target === 'claude-desktop') {
+        verifyJsonMcpTarget(items, 'claude-desktop', getClaudeDesktopConfigPath(HOME));
+    }
+    if (target === 'all' || target === 'chatgpt-desktop') {
+        verifyJsonMcpTarget(items, 'chatgpt-desktop', getChatgptDesktopConfigPath(HOME));
+    }
+    if (target === 'all' || target === 'cursor') {
+        verifyJsonMcpTarget(items, 'cursor', getCursorConfigPath(HOME));
+    }
+    if (target === 'all' || target === 'windsurf') {
+        verifyJsonMcpTarget(items, 'windsurf', getWindsurfConfigPath(HOME));
+    }
+    if (target === 'all' || target === 'vscode') {
+        verifyJsonMcpTarget(items, 'vscode', getVscodeConfigPath(HOME));
+    }
+    if (target === 'all' || target === 'gemini')
+        verifyGemini(items);
+    const hasError = items.some((item) => item.severity === 'error');
+    const hasWarn = items.some((item) => item.severity === 'warn');
+    if (options.json) {
+        process.stdout.write(JSON.stringify({
+            ok: !hasError,
+            warnings: hasWarn,
+            target,
+            checks: items,
+        }, null, 2) + '\n');
+    }
+    else {
+        process.stderr.write(`\n[gramatr-mcp] Setup verification target=${target}\n`);
+        for (const item of items) {
+            const marker = item.severity === 'ok' ? 'OK' : item.severity === 'warn' ? 'WARN' : 'ERROR';
+            process.stderr.write(`  [${marker}] ${item.label}: ${item.detail}\n`);
+        }
+    }
+    if (options.showPrompts) {
+        printPromptBlocks(target);
+    }
+    if (hasError) {
+        process.stderr.write('[gramatr-mcp] Verification failed. Re-run setup for the failing target(s).\n');
+        return 1;
+    }
+    if (hasWarn) {
+        process.stderr.write('[gramatr-mcp] Verification completed with warnings.\n');
+    }
+    else {
+        process.stderr.write('[gramatr-mcp] Verification passed.\n');
+    }
+    return 0;
+}
 //# sourceMappingURL=setup.js.map