@imenam/mcp-documentor 1.0.23

package/dist/src/tools/git-diff-doc.js

@@ -0,0 +1,93 @@
+import { execSync } from "child_process";
+import path from "path";
+import { GitDiffDocArgsSchema } from "../../shared/schemas/doc.schema.js";
+import { computeFreshness } from "./check-freshness.js";
+function getGitDiffForFile(tracked) {
+    const filePath = tracked.path;
+    const fileDir = path.dirname(filePath);
+    let repoRoot;
+    try {
+        repoRoot = execSync(`git -C "${fileDir}" rev-parse --show-toplevel`, { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return `  [ERROR] Not a git repository: ${filePath}`;
+    }
+    const relativeFilePath = path.relative(repoRoot, filePath).replace(/\\/g, "/");
+    let commitHash;
+    try {
+        commitHash = execSync(`git -C "${repoRoot}" log --before="${tracked.lastModifiedAt}" -1 --format=%H -- "${relativeFilePath}"`, { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return `  [ERROR] Could not retrieve git log for: ${filePath}`;
+    }
+    if (!commitHash) {
+        return `  [INFO] No commit found before snapshot date (${tracked.lastModifiedAt}) for: ${filePath}`;
+    }
+    let diff;
+    try {
+        diff = execSync(`git -C "${repoRoot}" diff ${commitHash} -- "${relativeFilePath}"`, { encoding: "utf-8" }).trim();
+    }
+    catch {
+        return `  [ERROR] Could not compute diff for: ${filePath}`;
+    }
+    if (!diff) {
+        return `  [INFO] No changes since snapshot (commit ${commitHash.slice(0, 7)}) for: ${filePath}`;
+    }
+    return diff;
+}
+export async function gitDiffDoc(storageEngine, args) {
+    try {
+        const validated = GitDiffDocArgsSchema.parse(args);
+        const docSections = [];
+        const seenFilePaths = new Set();
+        for (const docPath of validated.paths) {
+            const resolved = await storageEngine.resolveDoc(docPath);
+            if (!resolved) {
+                docSections.push(`## ${docPath}\n\n[ERROR] Documentation entry not found in any project.`);
+                continue;
+            }
+            const { doc } = resolved;
+            if (!doc.tracked_files || doc.tracked_files.length === 0) {
+                docSections.push(`## ${doc.title}\n\n[INFO] No tracked files.`);
+                continue;
+            }
+            let filesToDiff;
+            if (validated.file_paths) {
+                filesToDiff = doc.tracked_files.filter((tf) => validated.file_paths.includes(tf.path));
+            }
+            else {
+                const freshness = computeFreshness(doc.tracked_files);
+                const changedPaths = new Set([...freshness.modified, ...freshness.missing]);
+                filesToDiff = doc.tracked_files.filter((tf) => changedPaths.has(tf.path));
+            }
+            if (filesToDiff.length === 0) {
+                const msg = validated.file_paths
+                    ? "[INFO] No matching tracked files for the provided file_paths."
+                    : "[INFO] No modified or missing files detected since last snapshot. Documentation is up to date.";
+                docSections.push(`## ${doc.title}\n\n${msg}`);
+                continue;
+            }
+            const fileSections = filesToDiff
+                .filter((tf) => {
+                if (seenFilePaths.has(tf.path))
+                    return false;
+                seenFilePaths.add(tf.path);
+                return true;
+            })
+                .map((tf) => {
+                const diff = getGitDiffForFile(tf);
+                return `### ${tf.path}\nSnapshot date: ${tf.lastModifiedAt}\n\n${diff}`;
+            });
+            if (fileSections.length === 0) {
+                docSections.push(`## ${doc.title} [${docPath}]\n\n[INFO] All tracked files already shown in a previous documentation section.`);
+                continue;
+            }
+            docSections.push(`## ${doc.title} [${docPath}]\n\n${fileSections.join("\n\n---\n\n")}`);
+        }
+        return { content: [{ type: "text", text: docSections.join("\n\n═══════════════════════════════════\n\n") }] };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error computing git diff: ${message}` }] };
+    }
+}

package/dist/src/tools/list-docs.d.ts

@@ -0,0 +1,14 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+export declare function listDocs(storageEngine: StorageEngine, args?: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/src/tools/list-docs.js

@@ -0,0 +1,78 @@
+import { computeFreshness } from "./check-freshness.js";
+function renderProjectDocs(summaries, totalLabel) {
+    if (summaries.length === 0)
+        return "  (no entries)";
+    const groups = new Map();
+    for (const s of summaries) {
+        const key = s.folder ?? "";
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(s);
+    }
+    const sortedKeys = [...groups.keys()].sort((a, b) => {
+        if (a === "")
+            return 1;
+        if (b === "")
+            return -1;
+        return a.localeCompare(b);
+    });
+    const lines = [`${totalLabel}`];
+    for (const key of sortedKeys) {
+        if (key)
+            lines.push(`\n  📁 ${key}`);
+        for (const s of groups.get(key)) {
+            const staleTag = s.isStale ? " [STALE]" : "";
+            const tags = s.tags.length > 0 ? ` (${s.tags.join(", ")})` : "";
+            const indent = key ? "    " : "  ";
+            lines.push(`${indent}- ${s.title} [${s.id}]${tags}${staleTag} — updated ${s.updatedAt}`);
+        }
+    }
+    return lines.join("\n");
+}
+export async function listDocs(storageEngine, args) {
+    try {
+        const { project } = (args ?? {});
+        const config = storageEngine.getConfig();
+        const projectsToList = project ? [project] : config.projects;
+        const isMultiProject = projectsToList.length > 1;
+        if (!isMultiProject) {
+            const proj = projectsToList[0];
+            const summaries = await storageEngine.listDocs(proj);
+            for (const summary of summaries) {
+                const doc = await storageEngine.getDoc(summary.id, proj);
+                if (doc && doc.tracked_files.length > 0) {
+                    const report = computeFreshness(doc.tracked_files);
+                    summary.isStale = report.status === "stale";
+                }
+            }
+            if (summaries.length === 0) {
+                return { content: [{ type: "text", text: `No documentation entries found in project "${proj}".` }] };
+            }
+            const rendered = renderProjectDocs(summaries, `Documentation entries (${summaries.length}):`);
+            return { content: [{ type: "text", text: rendered }] };
+        }
+        // Multi-project: aggregate with project headers
+        const lines = [];
+        let grandTotal = 0;
+        for (const proj of projectsToList) {
+            const summaries = await storageEngine.listDocs(proj);
+            for (const summary of summaries) {
+                const doc = await storageEngine.getDoc(summary.id, proj);
+                if (doc && doc.tracked_files.length > 0) {
+                    const report = computeFreshness(doc.tracked_files);
+                    summary.isStale = report.status === "stale";
+                }
+            }
+            grandTotal += summaries.length;
+            lines.push(`\n🗂 ${proj} (${summaries.length})`);
+            lines.push(renderProjectDocs(summaries, ""));
+        }
+        return {
+            content: [{ type: "text", text: `Documentation entries — all projects (${grandTotal} total):${lines.join("\n")}` }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error listing docs: ${message}` }] };
+    }
+}

package/dist/src/tools/list-projects.d.ts

@@ -0,0 +1,14 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+export declare function listProjects(storageEngine: StorageEngine): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/src/tools/list-projects.js

@@ -0,0 +1,16 @@
+export async function listProjects(storageEngine) {
+    try {
+        const config = storageEngine.getConfig();
+        const lines = config.projects.map((p) => {
+            const marker = p === config.currentProject ? " (active)" : "";
+            return `- ${p}${marker}`;
+        });
+        return {
+            content: [{ type: "text", text: `Projects:\n\n${lines.join("\n")}\n\nCurrent project: ${config.currentProject}` }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error listing projects: ${message}` }] };
+    }
+}

package/dist/src/tools/move-doc.d.ts

@@ -0,0 +1,15 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+import type { EmbeddingEngine } from "../core/embedding-engine.js";
+export declare function moveDoc(storageEngine: StorageEngine, embeddingEngine: EmbeddingEngine, args: unknown): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/src/tools/move-doc.js

@@ -0,0 +1,34 @@
+import { MoveDocArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function moveDoc(storageEngine, embeddingEngine, args) {
+    try {
+        const validated = MoveDocArgsSchema.parse(args);
+        const resolved = await storageEngine.resolveDoc(validated.path);
+        if (!resolved) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Documentation entry "${validated.path}" not found in any project.` }],
+            };
+        }
+        const { project: resolvedProject } = resolved;
+        const moved = await storageEngine.moveDoc(validated.path, validated.new_path, resolvedProject);
+        if (!moved) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Failed to move "${validated.path}".` }],
+            };
+        }
+        await embeddingEngine.moveEmbedding(validated.path, validated.new_path, resolvedProject);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Documentation entry moved successfully.\nFrom: "${validated.path}"\nTo:   "${validated.new_path}"\n\nNote: if other documents reference "${validated.path}" in their related_docs or via doc:// links, use check_links to detect broken references.`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error moving doc: ${message}` }] };
+    }
+}

package/dist/src/tools/patch-doc.d.ts

@@ -0,0 +1,15 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+import type { EmbeddingEngine } from "../core/embedding-engine.js";
+export declare function patchDoc(storageEngine: StorageEngine, embeddingEngine: EmbeddingEngine, args: unknown): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/src/tools/patch-doc.js

@@ -0,0 +1,37 @@
+import { PatchDocArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function patchDoc(storageEngine, embeddingEngine, args) {
+    try {
+        const validated = PatchDocArgsSchema.parse(args);
+        const resolved = await storageEngine.resolveDoc(validated.path);
+        if (!resolved) {
+            return { isError: true, content: [{ type: "text", text: `Documentation entry "${validated.path}" not found in any project.` }] };
+        }
+        const { doc, project: resolvedProject } = resolved;
+        if (!doc.content.includes(validated.search)) {
+            const preview = doc.content.slice(0, 300).replace(/\n/g, "↵");
+            return {
+                isError: true,
+                content: [{
+                        type: "text",
+                        text: `Text to replace not found in "${validated.path}" (project: "${resolvedProject}").\nDoc content starts with: "${preview}…"\nTip: use get_doc to retrieve the exact current content before patching.`,
+                    }],
+            };
+        }
+        doc.content = doc.content.replace(validated.search, validated.replacement);
+        doc.updatedAt = new Date().toISOString();
+        await storageEngine.saveDoc(doc, resolvedProject);
+        if (embeddingEngine.isConfigured()) {
+            const embedding = await embeddingEngine.generateEmbedding(doc.content);
+            if (embedding) {
+                await embeddingEngine.saveEmbedding(validated.path, embedding, resolvedProject);
+            }
+        }
+        return {
+            content: [{ type: "text", text: `Documentation entry "${validated.path}" patched successfully.` }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error patching doc: ${message}` }] };
+    }
+}

package/dist/src/tools/refresh-file-snapshot.d.ts

@@ -0,0 +1,14 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+export declare function refreshFileSnapshot(storageEngine: StorageEngine, args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/src/tools/refresh-file-snapshot.js

@@ -0,0 +1,45 @@
+import fs from "fs";
+import { RefreshFileSnapshotArgsSchema } from "../../shared/schemas/doc.schema.js";
+import { computeFileHash } from "./check-freshness.js";
+export async function refreshFileSnapshot(storageEngine, args) {
+    try {
+        const validated = RefreshFileSnapshotArgsSchema.parse(args);
+        const docSections = [];
+        for (const docPath of validated.paths) {
+            const resolved = await storageEngine.resolveDoc(docPath);
+            if (!resolved) {
+                docSections.push(`**${docPath}**: not found in any project.`);
+                continue;
+            }
+            const { doc, project: resolvedProject } = resolved;
+            const refreshed = [];
+            const missing = [];
+            const skipped = [];
+            for (const tracked of doc.tracked_files) {
+                if (validated.file_paths && !validated.file_paths.includes(tracked.path)) {
+                    skipped.push(tracked.path);
+                    continue;
+                }
+                if (!fs.existsSync(tracked.path)) {
+                    missing.push(tracked.path);
+                    continue;
+                }
+                tracked.lastModifiedAt = fs.statSync(tracked.path).mtime.toISOString();
+                tracked.contentHash = computeFileHash(tracked.path);
+                refreshed.push(tracked.path);
+            }
+            await storageEngine.saveDoc(doc, resolvedProject);
+            let section = `**${doc.title}** [${docPath}]: refreshed ${refreshed.length}, missing ${missing.length}, skipped ${skipped.length}`;
+            if (refreshed.length > 0)
+                section += `\n${refreshed.map((f) => `  ✓ ${f}`).join("\n")}`;
+            if (missing.length > 0)
+                section += `\n${missing.map((f) => `  ✗ ${f}`).join("\n")}`;
+            docSections.push(section);
+        }
+        return { content: [{ type: "text", text: docSections.join("\n\n") }] };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error refreshing snapshot: ${message}` }] };
+    }
+}

package/dist/src/tools/search-docs.d.ts

@@ -0,0 +1,15 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+import type { EmbeddingEngine } from "../core/embedding-engine.js";
+export declare function searchDocs(storageEngine: StorageEngine, embeddingEngine: EmbeddingEngine, args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/src/tools/search-docs.js

@@ -0,0 +1,26 @@
+import { SearchDocsArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function searchDocs(storageEngine, embeddingEngine, args) {
+    try {
+        const validated = SearchDocsArgsSchema.parse(args);
+        const currentProject = storageEngine.getConfig().currentProject;
+        const results = await embeddingEngine.search(validated.query, currentProject, validated.top_k, async (id) => {
+            const doc = await storageEngine.getDoc(id);
+            if (!doc)
+                return null;
+            return { title: doc.title, content: doc.content };
+        });
+        if (results.length === 0) {
+            return { content: [{ type: "text", text: "No matching documentation entries found." }] };
+        }
+        const lines = results.map((r, i) => {
+            return `${i + 1}. **${r.title}** [${r.id}] — score: ${(r.score * 100).toFixed(1)}%\n   ${r.excerpt}...`;
+        });
+        return {
+            content: [{ type: "text", text: `Search results for "${validated.query}":\n\n${lines.join("\n\n")}` }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error searching docs: ${message}` }] };
+    }
+}

package/dist/src/tools/set-project.d.ts

@@ -0,0 +1,14 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+export declare function setProject(storageEngine: StorageEngine, args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/src/tools/set-project.js

@@ -0,0 +1,18 @@
+import { SetProjectArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function setProject(storageEngine, args) {
+    try {
+        const validated = SetProjectArgsSchema.parse(args);
+        const project = validated.project.replace(/[^a-zA-Z0-9_-]/g, "-");
+        storageEngine.ensureProject(project);
+        const config = storageEngine.getConfig();
+        config.currentProject = project;
+        storageEngine.saveConfig(config);
+        return {
+            content: [{ type: "text", text: `Switched to project "${project}". All subsequent operations will use this project.` }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error setting project: ${message}` }] };
+    }
+}

package/dist/src/tools/update-doc.d.ts

@@ -0,0 +1,15 @@
+import type { StorageEngine } from "../core/storage-engine.js";
+import type { EmbeddingEngine } from "../core/embedding-engine.js";
+export declare function updateDoc(storageEngine: StorageEngine, embeddingEngine: EmbeddingEngine, args: unknown): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/src/tools/update-doc.js

@@ -0,0 +1,66 @@
+import fs from "fs";
+import path from "path";
+import { UpdateDocArgsSchema } from "../../shared/schemas/doc.schema.js";
+import { computeFileHash } from "./check-freshness.js";
+function snapshotTrackedFiles(filePaths) {
+    const tracked = [];
+    for (const fp of filePaths) {
+        const absolutePath = path.resolve(process.cwd(), fp);
+        let mtime = new Date().toISOString();
+        let contentHash;
+        if (fs.existsSync(absolutePath)) {
+            mtime = fs.statSync(absolutePath).mtime.toISOString();
+            contentHash = computeFileHash(absolutePath);
+        }
+        tracked.push({ path: absolutePath, lastModifiedAt: mtime, ...(contentHash !== undefined && { contentHash }) });
+    }
+    return tracked;
+}
+export async function updateDoc(storageEngine, embeddingEngine, args) {
+    try {
+        const validated = UpdateDocArgsSchema.parse(args);
+        const resolved = await storageEngine.resolveDoc(validated.path);
+        if (!resolved) {
+            return { isError: true, content: [{ type: "text", text: `Documentation entry "${validated.path}" not found in any project.` }] };
+        }
+        const { doc, project: resolvedProject } = resolved;
+        if (validated.content !== undefined) {
+            doc.content = validated.content;
+        }
+        if (validated.tracked_files !== undefined) {
+            doc.tracked_files = snapshotTrackedFiles(validated.tracked_files);
+        }
+        if (validated.tags !== undefined) {
+            doc.tags = validated.tags;
+        }
+        if (validated.related_docs !== undefined) {
+            doc.related_docs = validated.related_docs;
+        }
+        doc.updatedAt = new Date().toISOString();
+        await storageEngine.saveDoc(doc, resolvedProject);
+        if (validated.content !== undefined && embeddingEngine.isConfigured()) {
+            const embedding = await embeddingEngine.generateEmbedding(validated.content);
+            if (embedding) {
+                await embeddingEngine.saveEmbedding(validated.path, embedding, resolvedProject);
+            }
+        }
+        const changes = [];
+        if (validated.content !== undefined)
+            changes.push("content");
+        if (validated.tracked_files !== undefined)
+            changes.push(`tracked_files (${doc.tracked_files.length} files)`);
+        if (validated.tags !== undefined)
+            changes.push(`tags (${doc.tags.join(", ") || "none"})`);
+        if (validated.related_docs !== undefined)
+            changes.push(`related_docs (${doc.related_docs.join(", ") || "none"})`);
+        return {
+            content: [
+                { type: "text", text: `Documentation entry "${validated.path}" updated.\nChanged: ${changes.join(", ")}` },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error updating doc: ${message}` }] };
+    }
+}

package/dist/src/version.d.ts

@@ -0,0 +1 @@
+export declare const APP_VERSION = "1.0.23";

package/dist/src/version.js

@@ -0,0 +1,2 @@
+// Auto-generated version file - do not edit manually
+export const APP_VERSION = '1.0.23';

package/gui/README.md

@@ -0,0 +1,75 @@
+# React + TypeScript + Vite
+
+This app is the browser UI for MCP Documentor. Shared MCP/proxy helpers live in the Node package `@imenam/mcp-gui-interface` (used from the repo root server and `gui-worker`, not from this Vite bundle).
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```