@praneeth_54/agentdoctor 0.1.0-beta

package/dist/agents/codex/detector.d.ts

@@ -0,0 +1,17 @@
+import type { AgentAdapter, AgentDetectionContext, AgentDetectionResult } from "../types.js";
+/**
+ * Codex project configuration detection.
+ *
+ * Official sources (Codex AGENTS.md / project config docs):
+ * - Project files: `AGENTS.md`, `AGENTS.override.md` (override wins at same directory)
+ * - Nested files from repo root down toward the working directory
+ * - Optional project-local Codex home via `CODEX_HOME=$(pwd)/.codex`
+ *   (we detect repo `.codex/AGENTS.md` and `.codex/config.toml` only)
+ *
+ * Fallback filenames (`project_doc_fallback_filenames`) are user-global config —
+ * we do not invent fallbacks; only official default names are detected.
+ *
+ * We do NOT read `~/.codex` for normal repository scans.
+ */
+export declare function detectCodex(context: AgentDetectionContext): Promise<AgentDetectionResult>;
+export declare const codexAdapter: AgentAdapter;

package/dist/agents/codex/detector.js

@@ -0,0 +1,151 @@
+import { AGENT_DISPLAY_NAMES } from "../../constants.js";
+import { deriveStatus, inspectRepoFile, pathExistsInsideRoot, toAgentConfigFile, } from "../inspect.js";
+import { basenameOf, isRootLevel } from "../types.js";
+/**
+ * Codex project configuration detection.
+ *
+ * Official sources (Codex AGENTS.md / project config docs):
+ * - Project files: `AGENTS.md`, `AGENTS.override.md` (override wins at same directory)
+ * - Nested files from repo root down toward the working directory
+ * - Optional project-local Codex home via `CODEX_HOME=$(pwd)/.codex`
+ *   (we detect repo `.codex/AGENTS.md` and `.codex/config.toml` only)
+ *
+ * Fallback filenames (`project_doc_fallback_filenames`) are user-global config —
+ * we do not invent fallbacks; only official default names are detected.
+ *
+ * We do NOT read `~/.codex` for normal repository scans.
+ */
+export async function detectCodex(context) {
+    const { root, discovery, maxFileSizeBytes } = context;
+    const configFiles = [];
+    const diagnostics = [];
+    const seen = new Set();
+    const metadata = {
+        agentsMdCount: 0,
+        overrideCount: 0,
+        hasProjectCodexDir: false,
+    };
+    const hasProjectCodexDir = await pathExistsInsideRoot(root, ".codex");
+    metadata.hasProjectCodexDir = hasProjectCodexDir;
+    async function addAgentsFile(relativePath, kind) {
+        if (seen.has(relativePath)) {
+            return;
+        }
+        seen.add(relativePath);
+        const inspected = await inspectRepoFile(root, relativePath, maxFileSizeBytes);
+        configFiles.push(toAgentConfigFile(inspected, kind, {
+            legacy: false,
+            scope: isRootLevel(relativePath) ? "root" : "nested",
+        }));
+        if (kind === "agents-md") {
+            metadata.agentsMdCount = Number(metadata.agentsMdCount) + 1;
+        }
+        else {
+            metadata.overrideCount = Number(metadata.overrideCount) + 1;
+        }
+        if (!inspected.exists) {
+            return;
+        }
+        if (!inspected.readable && inspected.error) {
+            diagnostics.push({
+                code: "codex/unreadable-file",
+                severity: "warning",
+                message: `Could not read Codex instruction file: ${inspected.error}`,
+                file: relativePath,
+            });
+        }
+        else if (inspected.empty) {
+            diagnostics.push({
+                code: "codex/empty-agents",
+                severity: "info",
+                // Official docs: Codex skips empty files
+                message: "Codex instruction file is empty (Codex skips empty files)",
+                file: relativePath,
+            });
+        }
+    }
+    for (const file of discovery.files) {
+        const relative = file.relativePath;
+        const base = basenameOf(relative);
+        if (base === "AGENTS.override.md") {
+            await addAgentsFile(relative, "agents-override-md");
+            continue;
+        }
+        if (base === "AGENTS.md") {
+            await addAgentsFile(relative, "agents-md");
+        }
+    }
+    // Explicit targeted checks for empty root files that discovery may still include
+    for (const relative of ["AGENTS.md", "AGENTS.override.md"]) {
+        if (!seen.has(relative) && (await pathExistsInsideRoot(root, relative))) {
+            await addAgentsFile(relative, relative === "AGENTS.override.md" ? "agents-override-md" : "agents-md");
+        }
+    }
+    // Optional project-local Codex home (CODEX_HOME=$(pwd)/.codex)
+    if (hasProjectCodexDir) {
+        for (const relative of [".codex/AGENTS.md", ".codex/AGENTS.override.md"]) {
+            if (await pathExistsInsideRoot(root, relative)) {
+                await addAgentsFile(relative, relative.endsWith("override.md") ? "agents-override-md" : "agents-md");
+            }
+        }
+        if (await pathExistsInsideRoot(root, ".codex/config.toml")) {
+            const inspected = await inspectRepoFile(root, ".codex/config.toml", maxFileSizeBytes);
+            configFiles.push(toAgentConfigFile(inspected, "codex-config", {
+                legacy: false,
+                scope: "root",
+            }));
+            // Existence only — TOML values are not parsed here.
+            if (inspected.empty) {
+                diagnostics.push({
+                    code: "codex/empty-config",
+                    severity: "info",
+                    message: ".codex/config.toml is empty",
+                    file: ".codex/config.toml",
+                });
+            }
+        }
+    }
+    const usableInstruction = configFiles.some((f) => f.readable && !f.empty && (f.kind === "agents-md" || f.kind === "agents-override-md"));
+    const detected = Number(metadata.agentsMdCount) > 0 || Number(metadata.overrideCount) > 0 || hasProjectCodexDir;
+    const configured = usableInstruction;
+    const hasErrors = diagnostics.some((d) => d.severity === "error");
+    const status = deriveStatus({ detected, configured, hasErrors });
+    const parts = [];
+    if (Number(metadata.agentsMdCount) > 0) {
+        parts.push(Number(metadata.agentsMdCount) === 1
+            ? "AGENTS.md"
+            : `${metadata.agentsMdCount} AGENTS.md files`);
+    }
+    if (Number(metadata.overrideCount) > 0) {
+        parts.push(Number(metadata.overrideCount) === 1
+            ? "AGENTS.override.md"
+            : `${metadata.overrideCount} overrides`);
+    }
+    let summary;
+    if (!detected) {
+        summary = "not configured";
+    }
+    else if (configured) {
+        summary = parts.length > 0 ? parts.join(", ") : "configured";
+    }
+    else {
+        summary = "detected but not configured";
+    }
+    return {
+        id: "codex",
+        displayName: AGENT_DISPLAY_NAMES.codex,
+        detected,
+        configured,
+        status,
+        summary,
+        configFiles,
+        configPaths: configFiles.map((f) => f.relativePath),
+        diagnostics,
+        metadata,
+    };
+}
+export const codexAdapter = {
+    id: "codex",
+    displayName: AGENT_DISPLAY_NAMES.codex,
+    detect: detectCodex,
+};

package/dist/agents/cursor/adapter.d.ts

@@ -0,0 +1 @@
+export { cursorAdapter, detectCursor } from "./detector.js";

package/dist/agents/cursor/adapter.js

@@ -0,0 +1 @@
+export { cursorAdapter, detectCursor } from "./detector.js";

package/dist/agents/cursor/detector.d.ts

@@ -0,0 +1,17 @@
+import type { AgentAdapter, AgentDetectionContext, AgentDetectionResult } from "../types.js";
+/**
+ * Cursor project configuration detection.
+ *
+ * Official sources (Cursor docs — Rules):
+ * - Project rules: `.cursor/rules/*.mdc` (Markdown + YAML frontmatter)
+ * - Plain `.md` under `.cursor/rules` is ignored by the rules system
+ * - `AGENTS.md` is an official simple alternative (root + nested)
+ *
+ * Legacy:
+ * - Root `.cursorrules` is still encountered in the wild and referenced by
+ *   other tools' migration paths; treated as legacy, not primary.
+ *
+ * We do not scan user-global Cursor settings — repository only.
+ */
+export declare function detectCursor(context: AgentDetectionContext): Promise<AgentDetectionResult>;
+export declare const cursorAdapter: AgentAdapter;

package/dist/agents/cursor/detector.js

@@ -0,0 +1,198 @@
+import { AGENT_DISPLAY_NAMES } from "../../constants.js";
+import { deriveStatus, inspectRepoFile, pathExistsInsideRoot, toAgentConfigFile, } from "../inspect.js";
+import { basenameOf, dirnameOf, isRootLevel } from "../types.js";
+/**
+ * Cursor project configuration detection.
+ *
+ * Official sources (Cursor docs — Rules):
+ * - Project rules: `.cursor/rules/*.mdc` (Markdown + YAML frontmatter)
+ * - Plain `.md` under `.cursor/rules` is ignored by the rules system
+ * - `AGENTS.md` is an official simple alternative (root + nested)
+ *
+ * Legacy:
+ * - Root `.cursorrules` is still encountered in the wild and referenced by
+ *   other tools' migration paths; treated as legacy, not primary.
+ *
+ * We do not scan user-global Cursor settings — repository only.
+ */
+export async function detectCursor(context) {
+    const { root, discovery, maxFileSizeBytes } = context;
+    const configFiles = [];
+    const diagnostics = [];
+    const metadata = {
+        mdcRuleCount: 0,
+        ignoredMdRuleCount: 0,
+        agentsMdCount: 0,
+        hasLegacyCursorrules: false,
+        hasCursorDirectory: false,
+    };
+    const hasCursorDir = await pathExistsInsideRoot(root, ".cursor");
+    metadata.hasCursorDirectory = hasCursorDir;
+    for (const file of discovery.files) {
+        const relative = file.relativePath;
+        const base = basenameOf(relative);
+        // Current project rules: any .mdc under a .cursor/rules/ segment
+        if (relative.includes(".cursor/rules/") && base.endsWith(".mdc")) {
+            const inspected = await inspectRepoFile(root, relative, maxFileSizeBytes);
+            const scope = relative.startsWith(".cursor/rules/") ? "root" : "nested";
+            const entry = toAgentConfigFile(inspected, "cursor-rule-mdc", {
+                legacy: false,
+                scope,
+            });
+            configFiles.push(entry);
+            metadata.mdcRuleCount = Number(metadata.mdcRuleCount) + 1;
+            if (!inspected.readable && inspected.error) {
+                diagnostics.push({
+                    code: "cursor/unreadable-rule",
+                    severity: "warning",
+                    message: `Could not read Cursor rule: ${inspected.error}`,
+                    file: relative,
+                });
+            }
+            else if (inspected.empty) {
+                diagnostics.push({
+                    code: "cursor/empty-rule",
+                    severity: "info",
+                    message: "Cursor rule file is empty",
+                    file: relative,
+                });
+            }
+            continue;
+        }
+        // Plain .md under .cursor/rules is ignored by Cursor's rules system
+        if (relative.includes(".cursor/rules/") && base.endsWith(".md")) {
+            const inspected = await inspectRepoFile(root, relative, maxFileSizeBytes);
+            configFiles.push(toAgentConfigFile(inspected, "cursor-rule-ignored-md", {
+                legacy: false,
+                scope: relative.startsWith(".cursor/rules/") ? "root" : "nested",
+            }));
+            metadata.ignoredMdRuleCount = Number(metadata.ignoredMdRuleCount) + 1;
+            diagnostics.push({
+                code: "cursor/ignored-md-rule",
+                severity: "warning",
+                message: "Plain .md files in .cursor/rules are ignored by Cursor; use .mdc with frontmatter or AGENTS.md",
+                file: relative,
+            });
+            continue;
+        }
+        // AGENTS.md — official Cursor alternative (root or nested)
+        if (base === "AGENTS.md") {
+            const inspected = await inspectRepoFile(root, relative, maxFileSizeBytes);
+            configFiles.push(toAgentConfigFile(inspected, "agents-md", {
+                legacy: false,
+                scope: isRootLevel(relative) ? "root" : "nested",
+            }));
+            metadata.agentsMdCount = Number(metadata.agentsMdCount) + 1;
+            if (inspected.empty) {
+                diagnostics.push({
+                    code: "cursor/empty-agents-md",
+                    severity: "info",
+                    message: "AGENTS.md is empty",
+                    file: relative,
+                });
+            }
+        }
+    }
+    // Legacy root .cursorrules (may not appear if empty — check explicitly)
+    if (await pathExistsInsideRoot(root, ".cursorrules")) {
+        const inspected = await inspectRepoFile(root, ".cursorrules", maxFileSizeBytes);
+        configFiles.push(toAgentConfigFile(inspected, "cursor-legacy-cursorrules", {
+            legacy: true,
+            scope: "legacy",
+        }));
+        metadata.hasLegacyCursorrules = true;
+        diagnostics.push({
+            code: "cursor/legacy-cursorrules",
+            severity: "warning",
+            message: "Legacy .cursorrules detected; prefer .cursor/rules/*.mdc or AGENTS.md per current Cursor docs",
+            file: ".cursorrules",
+        });
+        if (inspected.empty) {
+            diagnostics.push({
+                code: "cursor/empty-cursorrules",
+                severity: "info",
+                message: "Legacy .cursorrules is empty",
+                file: ".cursorrules",
+            });
+        }
+    }
+    else if (discovery.files.some((f) => f.relativePath === ".cursorrules")) {
+        // already covered via existence
+    }
+    // Detect empty .cursor tree with no usable rules
+    if (hasCursorDir && Number(metadata.mdcRuleCount) === 0) {
+        const hasRulesDir = await pathExistsInsideRoot(root, ".cursor/rules");
+        if (hasRulesDir) {
+            diagnostics.push({
+                code: "cursor/empty-rules-dir",
+                severity: "info",
+                message: ".cursor/rules exists but no .mdc project rules were found",
+                file: ".cursor/rules",
+            });
+        }
+        else {
+            diagnostics.push({
+                code: "cursor/no-rules",
+                severity: "info",
+                message: ".cursor directory exists without a rules/ project configuration",
+                file: ".cursor",
+            });
+        }
+    }
+    const usableInstruction = configFiles.some((f) => f.readable &&
+        !f.empty &&
+        (f.kind === "cursor-rule-mdc" ||
+            f.kind === "cursor-legacy-cursorrules" ||
+            f.kind === "agents-md"));
+    const detected = hasCursorDir ||
+        Boolean(metadata.hasLegacyCursorrules) ||
+        Number(metadata.mdcRuleCount) > 0 ||
+        Number(metadata.agentsMdCount) > 0 ||
+        Number(metadata.ignoredMdRuleCount) > 0;
+    const configured = usableInstruction;
+    const hasErrors = diagnostics.some((d) => d.severity === "error");
+    const status = deriveStatus({ detected, configured, hasErrors });
+    const parts = [];
+    if (Number(metadata.mdcRuleCount) > 0) {
+        parts.push(`${metadata.mdcRuleCount} project rule${Number(metadata.mdcRuleCount) === 1 ? "" : "s"}`);
+    }
+    if (Number(metadata.agentsMdCount) > 0) {
+        parts.push(`${metadata.agentsMdCount} AGENTS.md`);
+    }
+    if (metadata.hasLegacyCursorrules) {
+        parts.push("legacy .cursorrules");
+    }
+    let summary;
+    if (!detected) {
+        summary = "not configured";
+    }
+    else if (configured) {
+        summary = parts.length > 0 ? parts.join(", ") : "configured";
+    }
+    else {
+        summary = "detected but not configured";
+    }
+    // Silence unused dirname helper warning by referencing for nested path clarity in metadata
+    metadata.nestedRuleDirs = [
+        ...new Set(configFiles
+            .filter((f) => f.kind === "cursor-rule-mdc" && f.scope === "nested")
+            .map((f) => dirnameOf(f.relativePath))),
+    ];
+    return {
+        id: "cursor",
+        displayName: AGENT_DISPLAY_NAMES.cursor,
+        detected,
+        configured,
+        status,
+        summary,
+        configFiles,
+        configPaths: configFiles.map((f) => f.relativePath),
+        diagnostics,
+        metadata,
+    };
+}
+export const cursorAdapter = {
+    id: "cursor",
+    displayName: AGENT_DISPLAY_NAMES.cursor,
+    detect: detectCursor,
+};

package/dist/agents/detect-agents.d.ts

@@ -0,0 +1,17 @@
+import type { DiscoveryResult } from "../types/index.js";
+import { agentRegistry } from "./registry.js";
+import type { AgentDetectionResult } from "./types.js";
+export interface DetectAgentsOptions {
+    root: string;
+    discovery: DiscoveryResult;
+    maxFileSizeBytes?: number;
+    adapters?: typeof agentRegistry;
+}
+export interface DetectAgentsResult {
+    agents: AgentDetectionResult[];
+    elapsedMs: number;
+}
+/**
+ * Run all registered agent adapters against the repository.
+ */
+export declare function detectAgents(options: DetectAgentsOptions): Promise<DetectAgentsResult>;

package/dist/agents/detect-agents.js

@@ -0,0 +1,23 @@
+import { DEFAULT_MAX_FILE_SIZE_BYTES } from "../constants.js";
+import { agentRegistry } from "./registry.js";
+/**
+ * Run all registered agent adapters against the repository.
+ */
+export async function detectAgents(options) {
+    const started = performance.now();
+    const adapters = options.adapters ?? agentRegistry;
+    const maxFileSizeBytes = options.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+    const agents = [];
+    for (const adapter of adapters) {
+        const result = await adapter.detect({
+            root: options.root,
+            discovery: options.discovery,
+            maxFileSizeBytes,
+        });
+        agents.push(result);
+    }
+    return {
+        agents,
+        elapsedMs: Math.round(performance.now() - started),
+    };
+}

package/dist/agents/inspect.d.ts

@@ -0,0 +1,36 @@
+import type { AgentConfigFile, AgentConfigFileKind, AgentConfigScope, AgentConfigStatus } from "./types.js";
+export interface InspectedFile {
+    relativePath: string;
+    absolutePath: string;
+    exists: boolean;
+    readable: boolean;
+    sizeBytes: number;
+    empty: boolean;
+    isSymlink: boolean;
+    /** Raw UTF-8 text when readable and within size limit; otherwise null. */
+    text: string | null;
+    error?: string;
+}
+/**
+ * Safely inspect a file under the repository root.
+ * Never follows paths outside the root.
+ */
+export declare function inspectRepoFile(root: string, relativePath: string, maxFileSizeBytes?: number): Promise<InspectedFile>;
+export declare function pathExistsInsideRoot(root: string, relativePath: string): Promise<boolean>;
+export declare function toAgentConfigFile(inspected: InspectedFile, kind: AgentConfigFileKind, options?: {
+    legacy?: boolean;
+    scope?: AgentConfigScope;
+    parseError?: string;
+}): AgentConfigFile;
+export declare function tryParseJson(text: string): {
+    ok: true;
+    data: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function deriveStatus(options: {
+    detected: boolean;
+    configured: boolean;
+    hasErrors: boolean;
+}): AgentConfigStatus;

package/dist/agents/inspect.js

@@ -0,0 +1,165 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { DEFAULT_MAX_FILE_SIZE_BYTES } from "../constants.js";
+import { isPathInsideRoot, toPosixRelative } from "../utils/path.js";
+/**
+ * Safely inspect a file under the repository root.
+ * Never follows paths outside the root.
+ */
+export async function inspectRepoFile(root, relativePath, maxFileSizeBytes = DEFAULT_MAX_FILE_SIZE_BYTES) {
+    const absolutePath = path.resolve(root, relativePath);
+    const normalizedRelative = toPosixRelative(root, absolutePath);
+    if (!isPathInsideRoot(root, absolutePath)) {
+        return {
+            relativePath: normalizedRelative,
+            absolutePath,
+            exists: false,
+            readable: false,
+            sizeBytes: 0,
+            empty: true,
+            isSymlink: false,
+            text: null,
+            error: "Path escapes repository root",
+        };
+    }
+    try {
+        const lstat = await fs.lstat(absolutePath);
+        const isSymlink = lstat.isSymbolicLink();
+        if (isSymlink) {
+            const real = await fs.realpath(absolutePath);
+            if (!isPathInsideRoot(root, real)) {
+                return {
+                    relativePath: normalizedRelative,
+                    absolutePath,
+                    exists: true,
+                    readable: false,
+                    sizeBytes: 0,
+                    empty: true,
+                    isSymlink: true,
+                    text: null,
+                    error: "Symlink target is outside repository root",
+                };
+            }
+        }
+        const stat = await fs.stat(absolutePath);
+        if (!stat.isFile()) {
+            return {
+                relativePath: normalizedRelative,
+                absolutePath,
+                exists: true,
+                readable: false,
+                sizeBytes: 0,
+                empty: true,
+                isSymlink,
+                text: null,
+                error: "Not a regular file",
+            };
+        }
+        const sizeBytes = Number(stat.size);
+        if (sizeBytes === 0) {
+            return {
+                relativePath: normalizedRelative,
+                absolutePath,
+                exists: true,
+                readable: true,
+                sizeBytes: 0,
+                empty: true,
+                isSymlink,
+                text: "",
+            };
+        }
+        if (sizeBytes > maxFileSizeBytes) {
+            return {
+                relativePath: normalizedRelative,
+                absolutePath,
+                exists: true,
+                readable: false,
+                sizeBytes,
+                empty: false,
+                isSymlink,
+                text: null,
+                error: "File exceeds max size limit",
+            };
+        }
+        const text = await fs.readFile(absolutePath, "utf8");
+        const trimmedEmpty = text.trim().length === 0;
+        return {
+            relativePath: normalizedRelative,
+            absolutePath,
+            exists: true,
+            readable: true,
+            sizeBytes,
+            empty: trimmedEmpty,
+            isSymlink,
+            text,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unable to read file";
+        const code = error && typeof error === "object" && "code" in error
+            ? String(error.code)
+            : "";
+        return {
+            relativePath: normalizedRelative,
+            absolutePath,
+            exists: code !== "ENOENT",
+            readable: false,
+            sizeBytes: 0,
+            empty: true,
+            isSymlink: false,
+            text: null,
+            error: message,
+        };
+    }
+}
+export async function pathExistsInsideRoot(root, relativePath) {
+    const absolutePath = path.resolve(root, relativePath);
+    if (!isPathInsideRoot(root, absolutePath)) {
+        return false;
+    }
+    try {
+        await fs.access(absolutePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function toAgentConfigFile(inspected, kind, options = {}) {
+    const file = {
+        relativePath: inspected.relativePath,
+        kind,
+        sizeBytes: inspected.sizeBytes,
+        empty: inspected.empty,
+        readable: inspected.readable,
+        legacy: options.legacy ?? false,
+        scope: options.scope ?? (inspected.relativePath.includes("/") ? "nested" : "root"),
+    };
+    if (options.parseError !== undefined) {
+        file.parseError = options.parseError;
+    }
+    return file;
+}
+export function tryParseJson(text) {
+    try {
+        return { ok: true, data: JSON.parse(text) };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : "Invalid JSON",
+        };
+    }
+}
+export function deriveStatus(options) {
+    if (!options.detected) {
+        return "absent";
+    }
+    if (options.hasErrors && !options.configured) {
+        return "misconfigured";
+    }
+    if (options.configured) {
+        return options.hasErrors ? "misconfigured" : "configured";
+    }
+    return "detected";
+}

package/dist/agents/registry.d.ts

@@ -0,0 +1,7 @@
+import type { AgentAdapter } from "./types.js";
+/**
+ * Central registry of AI coding agent adapters.
+ * Add new agents by implementing AgentAdapter and appending here.
+ */
+export declare const agentRegistry: readonly AgentAdapter[];
+export declare function getAgentAdapter(id: string): AgentAdapter | undefined;

package/dist/agents/registry.js

@@ -0,0 +1,11 @@
+import { claudeAdapter } from "./claude/adapter.js";
+import { codexAdapter } from "./codex/adapter.js";
+import { cursorAdapter } from "./cursor/adapter.js";
+/**
+ * Central registry of AI coding agent adapters.
+ * Add new agents by implementing AgentAdapter and appending here.
+ */
+export const agentRegistry = [cursorAdapter, claudeAdapter, codexAdapter];
+export function getAgentAdapter(id) {
+    return agentRegistry.find((adapter) => adapter.id === id);
+}